| /contrib/network/netsurf/libdom/bindings/hubbub/Makefile |
|---|
| 0,0 → 1,8 |
| # Sources |
| OBJS := parser.o |
| OUTFILE = libo.o |
| CFLAGS += -I ./ -I ../../include/ -I ../../src/ -I ../../../libhubbub/include/ -I ../../../libwapcaplet/include/ |
| include $(MENUETDEV)/makefiles/Makefile_for_o_lib |
| /contrib/network/netsurf/libdom/bindings/hubbub/parser.c |
|---|
| 0,0 → 1,963 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #include <stdio.h> |
| #include <string.h> |
| #include "/home/sourcerer/kos_src/newenginek/kolibri/include/hubbub/errors.h" |
| #include "/home/sourcerer/kos_src/newenginek/kolibri/include/hubbub/hubbub.h" |
| #include "/home/sourcerer/kos_src/newenginek/kolibri/include/hubbub/parser.h" |
| #include <dom/dom.h> |
| //#include "errors.h" |
| #include "parser.h" |
| #include "utils.h" |
| #include "core/document.h" |
| #include "core/string.h" |
| #include "core/node.h" |
| #include "html/html_document.h" |
| #include "html/html_button_element.h" |
| #include "html/html_input_element.h" |
| #include "html/html_select_element.h" |
| #include "html/html_text_area_element.h" |
| #include <libwapcaplet/libwapcaplet.h> |
| /** |
| * libdom Hubbub parser context |
| */ |
| struct dom_hubbub_parser { |
| hubbub_parser *parser; /**< Hubbub parser instance */ |
| hubbub_tree_handler tree_handler; |
| /**< Hubbub parser tree handler */ |
| struct dom_document *doc; /**< DOM Document we're building */ |
| dom_hubbub_encoding_source encoding_source; |
| /**< The document's encoding source */ |
| const char *encoding; /**< The document's encoding */ |
| bool complete; /**< Indicate stream completion */ |
| dom_msg msg; /**< Informational messaging function */ |
| dom_script script; /**< Script callback function */ |
| void *mctx; /**< Pointer to client data */ |
| }; |
| /* Forward declaration to break reference loop */ |
| static hubbub_error add_attributes(void *parser, void *node, const hubbub_attribute *attributes, uint32_t n_attributes); |
| /*--------------------- The callbacks definitions --------------------*/ |
| static hubbub_error create_comment(void *parser, const hubbub_string *data, |
| void **result) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| dom_string *str; |
| struct dom_comment *comment; |
| *result = NULL; |
| err = dom_string_create(data->ptr, data->len, &str); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create comment node text"); |
| return HUBBUB_UNKNOWN; |
| } |
| err = dom_document_create_comment(dom_parser->doc, str, &comment); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(str); |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create comment node with text '%.*s'", |
| data->len, data->ptr); |
| return HUBBUB_UNKNOWN; |
| } |
| *result = comment; |
| dom_string_unref(str); |
| return HUBBUB_OK; |
| } |
| static char *parser_strndup(const char *s, size_t n) |
| { |
| size_t len; |
| char *s2; |
| for (len = 0; len != n && s[len] != '\0'; len++) |
| continue; |
| s2 = malloc(len + 1); |
| if (s2 == NULL) |
| return NULL; |
| memcpy(s2, s, len); |
| s2[len] = '\0'; |
| return s2; |
| } |
| static hubbub_error create_doctype(void *parser, const hubbub_doctype *doctype, |
| void **result) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| char *qname, *public_id = NULL, *system_id = NULL; |
| struct dom_document_type *dtype; |
| *result = NULL; |
| qname = parser_strndup((const char *) doctype->name.ptr, |
| (size_t) doctype->name.len); |
| if (qname == NULL) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create doctype name"); |
| goto fail; |
| } |
| if (doctype->public_missing == false) { |
| public_id = parser_strndup( |
| (const char *) doctype->public_id.ptr, |
| (size_t) doctype->public_id.len); |
| } else { |
| public_id = strdup(""); |
| } |
| if (public_id == NULL) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create doctype public id"); |
| goto clean1; |
| } |
| if (doctype->system_missing == false) { |
| system_id = parser_strndup( |
| (const char *) doctype->system_id.ptr, |
| (size_t) doctype->system_id.len); |
| } else { |
| system_id = strdup(""); |
| } |
| if (system_id == NULL) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create doctype system id"); |
| goto clean2; |
| } |
| err = dom_implementation_create_document_type(qname, |
| public_id, system_id, &dtype); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create the document type"); |
| goto clean3; |
| } |
| *result = dtype; |
| clean3: |
| free(system_id); |
| clean2: |
| free(public_id); |
| clean1: |
| free(qname); |
| fail: |
| if (*result == NULL) |
| return HUBBUB_UNKNOWN; |
| else |
| return HUBBUB_OK; |
| } |
| static hubbub_error create_element(void *parser, const hubbub_tag *tag, |
| void **result) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| dom_string *name; |
| struct dom_element *element = NULL; |
| hubbub_error herr; |
| *result = NULL; |
| err = dom_string_create_interned(tag->name.ptr, tag->name.len, &name); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create element name"); |
| goto fail; |
| } |
| if (tag->ns == HUBBUB_NS_NULL) { |
| err = dom_document_create_element(dom_parser->doc, name, |
| &element); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create the DOM element"); |
| goto clean1; |
| } |
| } else { |
| err = dom_document_create_element_ns(dom_parser->doc, |
| dom_namespaces[tag->ns], name, &element); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create the DOM element"); |
| goto clean1; |
| } |
| } |
| if (element != NULL && tag->n_attributes > 0) { |
| herr = add_attributes(parser, element, tag->attributes, |
| tag->n_attributes); |
| if (herr != HUBBUB_OK) |
| goto clean1; |
| } |
| *result = element; |
| clean1: |
| dom_string_unref(name); |
| fail: |
| if (*result == NULL) |
| return HUBBUB_UNKNOWN; |
| else |
| return HUBBUB_OK; |
| } |
| static hubbub_error create_text(void *parser, const hubbub_string *data, |
| void **result) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| dom_string *str; |
| struct dom_text *text = NULL; |
| *result = NULL; |
| err = dom_string_create(data->ptr, data->len, &str); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create text '%.*s'", data->len, |
| data->ptr); |
| goto fail; |
| } |
| err = dom_document_create_text_node(dom_parser->doc, str, &text); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create the DOM text node"); |
| goto clean1; |
| } |
| *result = text; |
| clean1: |
| dom_string_unref(str); |
| fail: |
| if (*result == NULL) |
| return HUBBUB_UNKNOWN; |
| else |
| return HUBBUB_OK; |
| } |
| static hubbub_error ref_node(void *parser, void *node) |
| { |
| struct dom_node *dnode = (struct dom_node *) node; |
| UNUSED(parser); |
| dom_node_ref(dnode); |
| return HUBBUB_OK; |
| } |
| static hubbub_error unref_node(void *parser, void *node) |
| { |
| struct dom_node *dnode = (struct dom_node *) node; |
| UNUSED(parser); |
| dom_node_unref(dnode); |
| return HUBBUB_OK; |
| } |
| static hubbub_error append_child(void *parser, void *parent, void *child, |
| void **result) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| err = dom_node_append_child((struct dom_node *) parent, |
| (struct dom_node *) child, |
| (struct dom_node **) result); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't append child '%p' for parent '%p'", |
| child, parent); |
| return HUBBUB_UNKNOWN; |
| } |
| return HUBBUB_OK; |
| } |
| static hubbub_error insert_before(void *parser, void *parent, void *child, |
| void *ref_child, void **result) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| err = dom_node_insert_before((struct dom_node *) parent, |
| (struct dom_node *) child, |
| (struct dom_node *) ref_child, |
| (struct dom_node **) result); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't insert node '%p' before node '%p'", |
| child, ref_child); |
| return HUBBUB_UNKNOWN; |
| } |
| return HUBBUB_OK; |
| } |
| static hubbub_error remove_child(void *parser, void *parent, void *child, |
| void **result) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| err = dom_node_remove_child((struct dom_node *) parent, |
| (struct dom_node *) child, |
| (struct dom_node **) result); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't remove child '%p'", child); |
| return HUBBUB_UNKNOWN; |
| } |
| return HUBBUB_OK; |
| } |
| static hubbub_error clone_node(void *parser, void *node, bool deep, |
| void **result) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| err = dom_node_clone_node((struct dom_node *) node, deep, |
| (struct dom_node **) result); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't clone node '%p'", node); |
| return HUBBUB_UNKNOWN; |
| } |
| return HUBBUB_OK; |
| } |
| static hubbub_error reparent_children(void *parser, void *node, |
| void *new_parent) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| struct dom_node *child, *result; |
| while(true) { |
| err = dom_node_get_first_child((struct dom_node *) node, |
| &child); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Error in dom_note_get_first_child"); |
| return HUBBUB_UNKNOWN; |
| } |
| if (child == NULL) |
| break; |
| err = dom_node_remove_child(node, (struct dom_node *) child, |
| &result); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Error in dom_node_remove_child"); |
| goto fail; |
| } |
| dom_node_unref(result); |
| err = dom_node_append_child((struct dom_node *) new_parent, |
| (struct dom_node *) child, &result); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Error in dom_node_append_child"); |
| goto fail; |
| } |
| dom_node_unref(result); |
| dom_node_unref(child); |
| } |
| return HUBBUB_OK; |
| fail: |
| dom_node_unref(child); |
| return HUBBUB_UNKNOWN; |
| } |
| static hubbub_error get_parent(void *parser, void *node, bool element_only, |
| void **result) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| struct dom_node *parent; |
| dom_node_type type = DOM_NODE_TYPE_COUNT; |
| err = dom_node_get_parent_node((struct dom_node *) node, |
| &parent); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Error in dom_node_get_parent"); |
| return HUBBUB_UNKNOWN; |
| } |
| if (element_only == false) { |
| *result = parent; |
| return HUBBUB_OK; |
| } |
| err = dom_node_get_node_type(parent, &type); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Error in dom_node_get_type"); |
| goto fail; |
| } |
| if (type == DOM_ELEMENT_NODE) { |
| *result = parent; |
| return HUBBUB_OK; |
| } else { |
| *result = NULL; |
| dom_node_unref(parent); |
| return HUBBUB_OK; |
| } |
| return HUBBUB_OK; |
| fail: |
| dom_node_unref(parent); |
| return HUBBUB_UNKNOWN; |
| } |
| static hubbub_error has_children(void *parser, void *node, bool *result) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| err = dom_node_has_child_nodes((struct dom_node *) node, result); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Error in dom_node_has_child_nodes"); |
| return HUBBUB_UNKNOWN; |
| } |
| return HUBBUB_OK; |
| } |
| static hubbub_error form_associate(void *parser, void *form, void *node) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_html_form_element *form_ele = form; |
| dom_node_internal *ele = node; |
| dom_html_document *doc = (dom_html_document *)ele->owner; |
| dom_exception err = DOM_NO_ERR; |
| /* Determine the kind of the node we have here. */ |
| if (dom_string_caseless_isequal(ele->name, |
| doc->memoised[hds_BUTTON])) { |
| err = _dom_html_button_element_set_form( |
| (dom_html_button_element *)node, form_ele); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Error in form_associate"); |
| return HUBBUB_UNKNOWN; |
| } |
| } else if (dom_string_caseless_isequal(ele->name, |
| doc->memoised[hds_INPUT])) { |
| err = _dom_html_input_element_set_form( |
| (dom_html_input_element *)node, form_ele); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Error in form_associate"); |
| return HUBBUB_UNKNOWN; |
| } |
| } else if (dom_string_caseless_isequal(ele->name, |
| doc->memoised[hds_SELECT])) { |
| err = _dom_html_select_element_set_form( |
| (dom_html_select_element *)node, form_ele); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Error in form_associate"); |
| return HUBBUB_UNKNOWN; |
| } |
| } else if (dom_string_caseless_isequal(ele->name, |
| doc->memoised[hds_TEXTAREA])) { |
| err = _dom_html_text_area_element_set_form( |
| (dom_html_text_area_element *)node, form_ele); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Error in form_associate"); |
| return HUBBUB_UNKNOWN; |
| } |
| } |
| return HUBBUB_OK; |
| } |
| static hubbub_error add_attributes(void *parser, void *node, |
| const hubbub_attribute *attributes, uint32_t n_attributes) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_exception err; |
| uint32_t i; |
| for (i = 0; i < n_attributes; i++) { |
| dom_string *name, *value; |
| err = dom_string_create_interned(attributes[i].name.ptr, |
| attributes[i].name.len, &name); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create attribute name"); |
| goto fail; |
| } |
| err = dom_string_create(attributes[i].value.ptr, |
| attributes[i].value.len, &value); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, dom_parser->mctx, |
| "Can't create attribute value"); |
| dom_string_unref(name); |
| goto fail; |
| } |
| if (attributes[i].ns == HUBBUB_NS_NULL) { |
| err = dom_element_set_attribute( |
| (struct dom_element *) node, name, |
| value); |
| dom_string_unref(name); |
| dom_string_unref(value); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, |
| dom_parser->mctx, |
| "Can't add attribute"); |
| } |
| } else { |
| err = dom_element_set_attribute_ns( |
| (struct dom_element *) node, |
| dom_namespaces[attributes[i].ns], name, |
| value); |
| dom_string_unref(name); |
| dom_string_unref(value); |
| if (err != DOM_NO_ERR) { |
| dom_parser->msg(DOM_MSG_CRITICAL, |
| dom_parser->mctx, |
| "Can't add attribute ns"); |
| } |
| } |
| } |
| return HUBBUB_OK; |
| fail: |
| return HUBBUB_UNKNOWN; |
| } |
| static hubbub_error set_quirks_mode(void *parser, hubbub_quirks_mode mode) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| switch (mode) { |
| case HUBBUB_QUIRKS_MODE_NONE: |
| dom_document_set_quirks_mode(dom_parser->doc, |
| DOM_DOCUMENT_QUIRKS_MODE_NONE); |
| break; |
| case HUBBUB_QUIRKS_MODE_LIMITED: |
| dom_document_set_quirks_mode(dom_parser->doc, |
| DOM_DOCUMENT_QUIRKS_MODE_LIMITED); |
| break; |
| case HUBBUB_QUIRKS_MODE_FULL: |
| dom_document_set_quirks_mode(dom_parser->doc, |
| DOM_DOCUMENT_QUIRKS_MODE_FULL); |
| break; |
| } |
| return HUBBUB_OK; |
| } |
| static hubbub_error change_encoding(void *parser, const char *charset) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| uint32_t source; |
| const char *name; |
| /* If we have an encoding here, it means we are *certain* */ |
| if (dom_parser->encoding != NULL) { |
| return HUBBUB_OK; |
| } |
| /* Find the confidence otherwise (can only be from a BOM) */ |
| name = hubbub_parser_read_charset(dom_parser->parser, &source); |
| if (source == HUBBUB_CHARSET_CONFIDENT) { |
| dom_parser->encoding_source = DOM_HUBBUB_ENCODING_SOURCE_DETECTED; |
| dom_parser->encoding = charset; |
| return HUBBUB_OK; |
| } |
| /* So here we have something of confidence tentative... */ |
| /* http://www.whatwg.org/specs/web-apps/current-work/#change */ |
| /* 2. "If the new encoding is identical or equivalent to the encoding |
| * that is already being used to interpret the input stream, then set |
| * the confidence to confident and abort these steps." */ |
| /* Whatever happens, the encoding should be set here; either for |
| * reprocessing with a different charset, or for confirming that the |
| * charset is in fact correct */ |
| dom_parser->encoding = charset; |
| dom_parser->encoding_source = DOM_HUBBUB_ENCODING_SOURCE_META; |
| /* Equal encodings will have the same string pointers */ |
| return (charset == name) ? HUBBUB_OK : HUBBUB_ENCODINGCHANGE; |
| } |
| static hubbub_error complete_script(void *parser, void *script) |
| { |
| dom_hubbub_parser *dom_parser = (dom_hubbub_parser *) parser; |
| dom_hubbub_error err; |
| err = dom_parser->script(dom_parser->mctx, (struct dom_node *)script); |
| if (err == DOM_HUBBUB_OK) { |
| return HUBBUB_OK; |
| } |
| if ((err & DOM_HUBBUB_HUBBUB_ERR) != 0) { |
| return err & (~DOM_HUBBUB_HUBBUB_ERR); |
| } |
| return HUBBUB_UNKNOWN; |
| } |
| static hubbub_tree_handler tree_handler = { |
| create_comment, |
| create_doctype, |
| create_element, |
| create_text, |
| ref_node, |
| unref_node, |
| append_child, |
| insert_before, |
| remove_child, |
| clone_node, |
| reparent_children, |
| get_parent, |
| has_children, |
| form_associate, |
| add_attributes, |
| set_quirks_mode, |
| change_encoding, |
| complete_script, |
| NULL |
| }; |
| /** |
| * Memory allocator |
| */ |
| static void *dom_hubbub_alloc(void *ptr, size_t len, void *pw) |
| { |
| UNUSED(pw); |
| if (ptr == NULL) |
| return len > 0 ? malloc(len) : NULL; |
| if (len == 0) { |
| free(ptr); |
| return NULL; |
| } |
| return realloc(ptr, len); |
| } |
| /** |
| * Default message callback |
| */ |
| static void dom_hubbub_parser_default_msg(uint32_t severity, void *ctx, |
| const char *msg, ...) |
| { |
| UNUSED(severity); |
| UNUSED(ctx); |
| UNUSED(msg); |
| } |
| /** |
| * Default script callback. |
| */ |
| static dom_hubbub_error |
| dom_hubbub_parser_default_script(void *ctx, struct dom_node *node) |
| { |
| UNUSED(ctx); |
| UNUSED(node); |
| return DOM_HUBBUB_OK; |
| } |
| /** |
| * Create a Hubbub parser instance |
| * |
| * \param params The binding creation parameters |
| * \param parser Pointer to location to recive instance. |
| * \param document Pointer to location to receive document. |
| * \return Error code |
| */ |
| dom_hubbub_error |
| dom_hubbub_parser_create(dom_hubbub_parser_params *params, |
| dom_hubbub_parser **parser, |
| dom_document **document) |
| { |
| dom_hubbub_parser *binding; |
| hubbub_parser_optparams optparams; |
| hubbub_error error; |
| dom_exception err; |
| dom_string *idname = NULL; |
| /* check result parameters */ |
| if (document == NULL) { |
| return DOM_HUBBUB_BADPARM; |
| } |
| if (parser == NULL) { |
| return DOM_HUBBUB_BADPARM; |
| } |
| /* setup binding parser context */ |
| binding = malloc(sizeof(dom_hubbub_parser)); |
| if (binding == NULL) { |
| return DOM_HUBBUB_NOMEM; |
| } |
| binding->parser = NULL; |
| binding->doc = NULL; |
| binding->encoding = params->enc; |
| if (params->enc != NULL) { |
| binding->encoding_source = DOM_HUBBUB_ENCODING_SOURCE_HEADER; |
| } else { |
| binding->encoding_source = DOM_HUBBUB_ENCODING_SOURCE_DETECTED; |
| } |
| binding->complete = false; |
| if (params->msg == NULL) { |
| binding->msg = dom_hubbub_parser_default_msg; |
| } else { |
| binding->msg = params->msg; |
| } |
| binding->mctx = params->ctx; |
| /* ensure script function is valid or use the default */ |
| if (params->script == NULL) { |
| binding->script = dom_hubbub_parser_default_script; |
| } else { |
| binding->script = params->script; |
| } |
| /* create hubbub parser */ |
| error = hubbub_parser_create(binding->encoding, |
| params->fix_enc, |
| dom_hubbub_alloc, |
| NULL, |
| &binding->parser); |
| if (error != HUBBUB_OK) { |
| free(binding); |
| return (DOM_HUBBUB_HUBBUB_ERR | error); |
| } |
| /* create DOM document */ |
| err = dom_implementation_create_document(DOM_IMPLEMENTATION_HTML, |
| NULL, |
| NULL, |
| NULL, |
| params->daf, |
| params->ctx, |
| &binding->doc); |
| if (err != DOM_NO_ERR) { |
| hubbub_parser_destroy(binding->parser); |
| free(binding); |
| return DOM_HUBBUB_DOM; |
| } |
| binding->tree_handler = tree_handler; |
| binding->tree_handler.ctx = (void *)binding; |
| /* set tree handler on parser */ |
| optparams.tree_handler = &binding->tree_handler; |
| hubbub_parser_setopt(binding->parser, |
| HUBBUB_PARSER_TREE_HANDLER, |
| &optparams); |
| /* set document node*/ |
| optparams.document_node = dom_node_ref((struct dom_node *)binding->doc); |
| hubbub_parser_setopt(binding->parser, |
| HUBBUB_PARSER_DOCUMENT_NODE, |
| &optparams); |
| /* set scripting state */ |
| optparams.enable_scripting = params->enable_script; |
| hubbub_parser_setopt(binding->parser, |
| HUBBUB_PARSER_ENABLE_SCRIPTING, |
| &optparams); |
| /* set the document id parameter before the parse so searches |
| * based on id succeed. |
| */ |
| err = dom_string_create_interned((const uint8_t *) "id", |
| SLEN("id"), |
| &idname); |
| if (err != DOM_NO_ERR) { |
| binding->msg(DOM_MSG_ERROR, binding->mctx, "Can't set DOM document id name"); |
| hubbub_parser_destroy(binding->parser); |
| free(binding); |
| return DOM_HUBBUB_DOM; |
| } |
| _dom_document_set_id_name(binding->doc, idname); |
| dom_string_unref(idname); |
| /* set return parameters */ |
| *document = (dom_document *)dom_node_ref(binding->doc); |
| *parser = binding; |
| return DOM_HUBBUB_OK; |
| } |
| dom_hubbub_error |
| dom_hubbub_parser_insert_chunk(dom_hubbub_parser *parser, |
| const uint8_t *data, |
| size_t length) |
| { |
| hubbub_parser_insert_chunk(parser->parser, data, length); |
| return DOM_HUBBUB_OK; |
| } |
| /** |
| * Destroy a Hubbub parser instance |
| * |
| * \param parser The Hubbub parser object |
| */ |
| void dom_hubbub_parser_destroy(dom_hubbub_parser *parser) |
| { |
| hubbub_parser_destroy(parser->parser); |
| parser->parser = NULL; |
| if (parser->doc != NULL) { |
| dom_node_unref((struct dom_node *) parser->doc); |
| parser->doc = NULL; |
| } |
| free(parser); |
| } |
| /** |
| * Parse data with Hubbub parser |
| * |
| * \param parser The parser object |
| * \param data The data to be parsed |
| * \param len The length of the data to be parsed |
| * \return DOM_HUBBUB_OK on success, |
| * DOM_HUBBUB_HUBBUB_ERR | <hubbub_error> on failure |
| */ |
| dom_hubbub_error dom_hubbub_parser_parse_chunk(dom_hubbub_parser *parser, |
| const uint8_t *data, size_t len) |
| { |
| hubbub_error err; |
| err = hubbub_parser_parse_chunk(parser->parser, data, len); |
| if (err != HUBBUB_OK) |
| return DOM_HUBBUB_HUBBUB_ERR | err; |
| return DOM_HUBBUB_OK; |
| } |
| /** |
| * Notify the parser to complete parsing |
| * |
| * \param parser The parser object |
| * \return DOM_HUBBUB_OK on success, |
| * DOM_HUBBUB_HUBBUB_ERR | <hubbub_error> on underlaying parser failure |
| * DOMHUBBUB_UNKNOWN | <lwc_error> on libwapcaplet failure |
| */ |
| dom_hubbub_error dom_hubbub_parser_completed(dom_hubbub_parser *parser) |
| { |
| hubbub_error err; |
| err = hubbub_parser_completed(parser->parser); |
| if (err != HUBBUB_OK) { |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "hubbub_parser_completed failed: %d", err); |
| return DOM_HUBBUB_HUBBUB_ERR | err; |
| } |
| parser->complete = true; |
| return DOM_HUBBUB_OK; |
| } |
| /** |
| * Retrieve the encoding |
| * |
| * \param parser The parser object |
| * \param source The encoding_source |
| * \return the encoding name |
| */ |
| const char *dom_hubbub_parser_get_encoding(dom_hubbub_parser *parser, |
| dom_hubbub_encoding_source *source) |
| { |
| *source = parser->encoding_source; |
| return parser->encoding != NULL ? parser->encoding |
| : "Windows-1252"; |
| } |
| /** |
| * Set the Parse pause state. |
| * |
| * \param parser The parser object |
| * \param pause The pause state to set. |
| * \return DOM_HUBBUB_OK on success, |
| * DOM_HUBBUB_HUBBUB_ERR | <hubbub_error> on failure |
| */ |
| dom_hubbub_error dom_hubbub_parser_pause(dom_hubbub_parser *parser, bool pause) |
| { |
| hubbub_error err; |
| hubbub_parser_optparams params; |
| params.pause_parse = pause; |
| err = hubbub_parser_setopt(parser->parser, HUBBUB_PARSER_PAUSE, ¶ms); |
| if (err != HUBBUB_OK) |
| return DOM_HUBBUB_HUBBUB_ERR | err; |
| return DOM_HUBBUB_OK; |
| } |
| /contrib/network/netsurf/libdom/bindings/hubbub/README |
|---|
| 0,0 → 1,8 |
| Hubbub binding for libdom |
| ========================= |
| This is a wrapper around hubbub's parser API, to facilitate |
| construction of a libdom DOM tree. The basic premise is that the wrapper |
| intercepts the SAX-like events emitted by hubbub's tokeniser then builds |
| a libdom DOM tree from them. |
| /contrib/network/netsurf/libdom/bindings/hubbub/errors.h |
|---|
| 0,0 → 1,44 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_hubbub_errors_h_ |
| #define dom_hubbub_errors_h_ |
| #include <hubbub/errors.h> |
| typedef enum { |
| DOM_HUBBUB_OK = 0, |
| DOM_HUBBUB_NOMEM = 1, |
| DOM_HUBBUB_BADPARM = 2, /**< Bad input parameter */ |
| DOM_HUBBUB_DOM = 3, /**< DOM operation failed */ |
| DOM_HUBBUB_HUBBUB_ERR = (1<<16), |
| DOM_HUBBUB_HUBBUB_ERR_PAUSED = (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_PAUSED), |
| DOM_HUBBUB_HUBBUB_ERR_ENCODINGCHANGE = (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_ENCODINGCHANGE), |
| DOM_HUBBUB_HUBBUB_ERR_NOMEM = (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_NOMEM), |
| DOM_HUBBUB_HUBBUB_ERR_BADPARM = (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_BADPARM), |
| DOM_HUBBUB_HUBBUB_ERR_INVALID = (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_INVALID), |
| DOM_HUBBUB_HUBBUB_ERR_FILENOTFOUND = (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_FILENOTFOUND), |
| DOM_HUBBUB_HUBBUB_ERR_NEEDDATA = (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_NEEDDATA), |
| DOM_HUBBUB_HUBBUB_ERR_BADENCODING = (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_BADENCODING), |
| DOM_HUBBUB_HUBBUB_ERR_UNKNOWN = (DOM_HUBBUB_HUBBUB_ERR | HUBBUB_UNKNOWN), |
| } dom_hubbub_error; |
| #endif |
| /contrib/network/netsurf/libdom/bindings/hubbub/parser.h |
|---|
| 0,0 → 1,101 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_hubbub_parser_h_ |
| #define dom_hubbub_parser_h_ |
| #include <stddef.h> |
| #include <inttypes.h> |
| #include <hubbub/errors.h> |
| #include <dom/dom.h> |
| #include "errors.h" |
| /** |
| * Type of script completion function |
| */ |
| typedef dom_hubbub_error (*dom_script)(void *ctx, struct dom_node *node); |
| typedef struct dom_hubbub_parser dom_hubbub_parser; |
| /* The encoding source of the document */ |
| typedef enum dom_hubbub_encoding_source { |
| DOM_HUBBUB_ENCODING_SOURCE_HEADER, |
| DOM_HUBBUB_ENCODING_SOURCE_DETECTED, |
| DOM_HUBBUB_ENCODING_SOURCE_META |
| } dom_hubbub_encoding_source; |
| /* The recommended way to use the parser is: |
| * |
| * dom_hubbub_parser_create(...); |
| * dom_hubbub_parser_parse_chunk(...); |
| * call _parse_chunk for all chunks of data |
| * |
| * After you have parsed the data, |
| * |
| * dom_hubbub_parser_completed(...); |
| * dom_hubbub_parser_destroy(...); |
| * |
| * Clients must ensure that these function calls above are called in |
| * the order shown. dom_hubbub_parser_create() will pass the ownership |
| * of the document to the client. After that, the parser should be destroyed. |
| * The client must not call any method of this parser after destruction. |
| */ |
| /** |
| * Parameter block for dom_hubbub_parser_create |
| */ |
| typedef struct dom_hubbub_parser_params { |
| const char *enc; /**< Source charset, or NULL */ |
| bool fix_enc; /**< Whether fix the encoding */ |
| bool enable_script; /**< Whether scripting should be enabled. */ |
| dom_script script; /**< Script callback function */ |
| dom_msg msg; /**< Informational message function */ |
| void *ctx; /**< Pointer to client-specific private data */ |
| /** default action fetcher function */ |
| dom_events_default_action_fetcher daf; |
| } dom_hubbub_parser_params; |
| /* Create a Hubbub parser instance */ |
| dom_hubbub_error dom_hubbub_parser_create(dom_hubbub_parser_params *params, |
| dom_hubbub_parser **parser, |
| dom_document **document); |
| /* Destroy a Hubbub parser instance */ |
| void dom_hubbub_parser_destroy(dom_hubbub_parser *parser); |
| /* Parse a chunk of data */ |
| dom_hubbub_error dom_hubbub_parser_parse_chunk(dom_hubbub_parser *parser, |
| const uint8_t *data, size_t len); |
| /* insert data into the parse stream but do not parse it */ |
| dom_hubbub_error dom_hubbub_parser_insert_chunk(dom_hubbub_parser *parser, |
| const uint8_t *data, size_t length); |
| /* Notify parser that datastream is empty */ |
| dom_hubbub_error dom_hubbub_parser_completed(dom_hubbub_parser *parser); |
| /* Retrieve the document's encoding */ |
| const char *dom_hubbub_parser_get_encoding(dom_hubbub_parser *parser, |
| dom_hubbub_encoding_source *source); |
| /** |
| * Set the Parse pause state. |
| * |
| * \param parser The parser object |
| * \param pause The pause state to set. |
| * \return DOM_HUBBUB_OK on success, |
| * DOM_HUBBUB_HUBBUB_ERR | <hubbub_error> on failure |
| */ |
| dom_hubbub_error dom_hubbub_parser_pause(dom_hubbub_parser *parser, bool pause); |
| #endif |
| /contrib/network/netsurf/libdom/bindings/hubbub/utils.h |
|---|
| 0,0 → 1,28 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_hubbub_utils_h_ |
| #define dom_hubbub_utils_h_ |
| #ifndef max |
| #define max(a,b) ((a)>(b)?(a):(b)) |
| #endif |
| #ifndef min |
| #define min(a,b) ((a)<(b)?(a):(b)) |
| #endif |
| #ifndef SLEN |
| /* Calculate length of a string constant */ |
| #define SLEN(s) (sizeof((s)) - 1) /* -1 for '\0' */ |
| #endif |
| #ifndef UNUSED |
| #define UNUSED(x) ((x)=(x)) |
| #endif |
| #endif |
| /contrib/network/netsurf/libdom/bindings/Makefile |
|---|
| 0,0 → 1,3 |
| # Bindings |
| include $(NSBUILD)/Makefile.subdir |
| /contrib/network/netsurf/libdom/bindings/xml/Makefile |
|---|
| 0,0 → 1,33 |
| ifeq ($(WITH_LIBXML_BINDING),yes) |
| DIR_SOURCES := libxml_xmlparser.c |
| # LibXML2 |
| ifneq ($(PKGCONFIG),) |
| CFLAGS := $(CFLAGS) $(shell $(PKGCONFIG) libxml-2.0 --cflags) |
| LDFLAGS := $(LDFLAGS) $(shell $(PKGCONFIG) libxml-2.0 --libs) |
| else |
| CFLAGS := $(CFLAGS) -I$(PREFIX)/include/libxml2 |
| LDFLAGS := $(LDFLAGS) -lxml2 |
| endif |
| # LibXML 2.6.26 has a bug in its headers that expects _POSIX_C_SOURCE to be |
| # defined. Define it here, even though we don't need it. |
| CFLAGS := $(CFLAGS) -D_POSIX_C_SOURCE |
| DO_XML_INSTALL := yes |
| endif |
| ifeq ($(WITH_EXPAT_BINDING),yes) |
| DIR_SOURCES := expat_xmlparser.c |
| LDFLAGS := $(LDFLAGS) -lexpat |
| DO_XML_INSTALL := yes |
| endif |
| ifeq ($(DO_XML_INSTALL),yes) |
| DIR_INSTALL_ITEMS := /include/dom/bindings/xml:xmlerror.h;xmlparser.h |
| endif |
| include $(NSBUILD)/Makefile.subdir |
| /contrib/network/netsurf/libdom/bindings/xml/README |
|---|
| 0,0 → 1,14 |
| LibXML binding for libdom |
| ========================= |
| This is a wrapper around libxml's push parser API, to facilitate |
| construction of a libdom DOM tree. The basic premise is that the wrapper |
| intercepts the SAX events emitted by libxml's tokeniser then invokes |
| libxml's own SAX handlers, wrapping the results up in libdom-specific |
| data structures. |
| The tree created is thus a tree of libdom nodes, each of which is linked |
| to the libxml node that backs it. This allows the binding to process the |
| DOM tree using libxml api, should it need to (e.g. for normalization |
| purposes). |
| /contrib/network/netsurf/libdom/bindings/xml/expat_xmlparser.c |
|---|
| 0,0 → 1,589 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #include <stdbool.h> |
| #include <string.h> |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <dom/dom.h> |
| #include "xmlparser.h" |
| #include "utils.h" |
| #include <expat.h> |
| /** |
| * expat XML parser object |
| */ |
| struct dom_xml_parser { |
| dom_msg msg; /**< Informational message function */ |
| void *mctx; /**< Pointer to client data */ |
| XML_Parser parser; /**< expat parser context */ |
| struct dom_document *doc; /**< DOM Document we're building */ |
| struct dom_node *current; /**< DOM node we're currently building */ |
| bool is_cdata; /**< If the character data is cdata or text */ |
| }; |
| /* Binding functions */ |
| static void |
| expat_xmlparser_start_element_handler(void *_parser, |
| const XML_Char *name, |
| const XML_Char **atts) |
| { |
| dom_xml_parser *parser = _parser; |
| dom_exception err; |
| dom_element *elem, *ins_elem; |
| dom_string *tag_name; |
| dom_string *namespace = NULL; |
| const XML_Char *ns_sep = strchr(name, '\n'); |
| if (ns_sep != NULL) { |
| err = dom_string_create_interned((const uint8_t *)name, |
| ns_sep - name, |
| &namespace); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for namespace name"); |
| return; |
| } |
| name = ns_sep + 1; |
| } |
| err = dom_string_create_interned((const uint8_t *)name, |
| strlen(name), |
| &tag_name); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for tag name"); |
| if (namespace != NULL) |
| dom_string_unref(namespace); |
| return; |
| } |
| if (namespace == NULL) |
| err = dom_document_create_element(parser->doc, |
| tag_name, &elem); |
| else |
| err = dom_document_create_element_ns(parser->doc, namespace, |
| tag_name, &elem); |
| if (err != DOM_NO_ERR) { |
| if (namespace != NULL) |
| dom_string_unref(namespace); |
| dom_string_unref(tag_name); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed to create element '%s'", name); |
| return; |
| } |
| dom_string_unref(tag_name); |
| if (namespace != NULL) |
| dom_string_unref(namespace); |
| /* Add attributes to the element */ |
| while (*atts) { |
| dom_string *key, *value; |
| ns_sep = strchr(*atts, '\n'); |
| if (ns_sep != NULL) { |
| err = dom_string_create_interned((const uint8_t *)(*atts), |
| ns_sep - (*atts), |
| &namespace); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for attr namespace"); |
| dom_node_unref(elem); |
| return; |
| } |
| } else |
| namespace = NULL; |
| if (ns_sep == NULL) |
| err = dom_string_create_interned((const uint8_t *)(*atts), |
| strlen(*atts), &key); |
| else |
| err = dom_string_create_interned((const uint8_t *)(ns_sep + 1), |
| strlen(ns_sep + 1), |
| &key); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for attribute name"); |
| if (namespace != NULL) |
| dom_string_unref(namespace); |
| dom_node_unref(elem); |
| return; |
| } |
| atts++; |
| err = dom_string_create((const uint8_t *)(*atts), |
| strlen(*atts), &value); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(elem); |
| if (namespace != NULL) |
| dom_string_unref(namespace); |
| dom_string_unref(key); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for attribute value"); |
| return; |
| } |
| atts++; |
| if (namespace == NULL) |
| err = dom_element_set_attribute(elem, key, value); |
| else |
| err = dom_element_set_attribute_ns(elem, namespace, |
| key, value); |
| if (namespace != NULL) |
| dom_string_unref(namespace); |
| dom_string_unref(key); |
| dom_string_unref(value); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(elem); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for setting attribute"); |
| return; |
| } |
| } |
| err = dom_node_append_child(parser->current, (struct dom_node *) elem, |
| (struct dom_node **) (void *) &ins_elem); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(elem); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for appending child node"); |
| return; |
| } |
| dom_node_unref(ins_elem); |
| dom_node_unref(parser->current); |
| parser->current = (struct dom_node *)elem; /* Steal initial ref */ |
| } |
| static void |
| expat_xmlparser_end_element_handler(void *_parser, |
| const XML_Char *name) |
| { |
| dom_xml_parser *parser = _parser; |
| dom_exception err; |
| dom_node *parent; |
| UNUSED(name); |
| err = dom_node_get_parent_node(parser->current, &parent); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Unable to find a parent while closing element."); |
| return; |
| } |
| dom_node_unref(parser->current); |
| parser->current = parent; /* Takes the ref given by get_parent_node */ |
| } |
| static void |
| expat_xmlparser_start_cdata_handler(void *_parser) |
| { |
| dom_xml_parser *parser = _parser; |
| parser->is_cdata = true; |
| } |
| static void |
| expat_xmlparser_end_cdata_handler(void *_parser) |
| { |
| dom_xml_parser *parser = _parser; |
| parser->is_cdata = false; |
| } |
| static void |
| expat_xmlparser_cdata_handler(void *_parser, |
| const XML_Char *s, |
| int len) |
| { |
| dom_xml_parser *parser = _parser; |
| dom_string *data; |
| dom_exception err; |
| struct dom_node *cdata, *ins_cdata, *lastchild = NULL; |
| dom_node_type ntype = 0; |
| err = dom_string_create((const uint8_t *)s, len, &data); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for cdata section contents"); |
| return; |
| } |
| err = dom_node_get_last_child(parser->current, &lastchild); |
| if (err == DOM_NO_ERR && lastchild != NULL) { |
| err = dom_node_get_node_type(lastchild, &ntype); |
| } |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(data); |
| if (lastchild != NULL) |
| dom_node_unref(lastchild); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for cdata section"); |
| return; |
| } |
| if (ntype == DOM_TEXT_NODE && parser->is_cdata == false) { |
| /* We can append this text instead */ |
| err = dom_characterdata_append_data( |
| (dom_characterdata *)lastchild, data); |
| dom_string_unref(data); |
| if (lastchild != NULL) |
| dom_node_unref(lastchild); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for cdata section"); |
| } |
| return; |
| } |
| if (lastchild != NULL) |
| dom_node_unref(lastchild); |
| /* We can't append directly, so make a new node */ |
| err = parser->is_cdata ? |
| dom_document_create_cdata_section(parser->doc, data, |
| (dom_cdata_section **) (void *) &cdata) : |
| dom_document_create_text_node(parser->doc, data, |
| (dom_text **) (void *) &cdata); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(data); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for cdata section"); |
| return; |
| } |
| /* No longer need data */ |
| dom_string_unref(data); |
| /* Append cdata section to parent */ |
| err = dom_node_append_child(parser->current, cdata, &ins_cdata); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) cdata); |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "Failed attaching cdata section"); |
| return; |
| } |
| /* We're not interested in the inserted cdata section */ |
| if (ins_cdata != NULL) |
| dom_node_unref(ins_cdata); |
| /* No longer interested in cdata section */ |
| dom_node_unref(cdata); |
| } |
| static int |
| expat_xmlparser_external_entity_ref_handler(XML_Parser parser, |
| const XML_Char *context, |
| const XML_Char *base, |
| const XML_Char *system_id, |
| const XML_Char *public_id) |
| { |
| FILE *fh; |
| XML_Parser subparser; |
| unsigned char data[1024]; |
| size_t len; |
| enum XML_Status status; |
| UNUSED(base); |
| UNUSED(public_id); |
| if (system_id == NULL) |
| return XML_STATUS_OK; |
| fh = fopen(system_id, "r"); |
| if (fh == NULL) |
| return XML_STATUS_OK; |
| subparser = XML_ExternalEntityParserCreate(parser, |
| context, |
| NULL); |
| if (subparser == NULL) { |
| fclose(fh); |
| return XML_STATUS_OK; |
| } |
| /* Parse the file bit by bit */ |
| while ((len = fread(data, 1, 1024, fh)) > 0) { |
| status = XML_Parse(subparser, (const char *)data, len, 0); |
| if (status != XML_STATUS_OK) { |
| XML_ParserFree(subparser); |
| fclose(fh); |
| return XML_STATUS_OK; |
| } |
| } |
| XML_Parse(subparser, "", 0, 1); |
| XML_ParserFree(subparser); |
| fclose(fh); |
| return XML_STATUS_OK; |
| } |
| static void |
| expat_xmlparser_comment_handler(void *_parser, |
| const XML_Char *_comment) |
| { |
| dom_xml_parser *parser = _parser; |
| struct dom_comment *comment, *ins_comment = NULL; |
| dom_string *data; |
| dom_exception err; |
| /* Create DOM string data for comment */ |
| err = dom_string_create((const uint8_t *)_comment, |
| strlen((const char *) _comment), &data); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for comment data"); |
| return; |
| } |
| /* Create comment */ |
| err = dom_document_create_comment(parser->doc, data, &comment); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(data); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for comment node"); |
| return; |
| } |
| /* No longer need data */ |
| dom_string_unref(data); |
| /* Append comment to parent */ |
| err = dom_node_append_child(parser->current, (struct dom_node *) comment, |
| (struct dom_node **) (void *) &ins_comment); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) comment); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed attaching comment node"); |
| return; |
| } |
| /* We're not interested in the inserted comment */ |
| if (ins_comment != NULL) |
| dom_node_unref((struct dom_node *) ins_comment); |
| /* No longer interested in comment */ |
| dom_node_unref((struct dom_node *) comment); |
| } |
| static void |
| expat_xmlparser_start_doctype_decl_handler(void *_parser, |
| const XML_Char *doctype_name, |
| const XML_Char *system_id, |
| const XML_Char *public_id, |
| int has_internal_subset) |
| { |
| dom_xml_parser *parser = _parser; |
| struct dom_document_type *doctype, *ins_doctype = NULL; |
| dom_exception err; |
| UNUSED(has_internal_subset); |
| err = dom_implementation_create_document_type( |
| doctype_name, system_id ? system_id : "", |
| public_id ? public_id : "", |
| &doctype); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed to create document type"); |
| return; |
| } |
| /* Add doctype to document */ |
| err = dom_node_append_child(parser->doc, (struct dom_node *) doctype, |
| (struct dom_node **) (void *) &ins_doctype); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) doctype); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed attaching doctype"); |
| return; |
| } |
| /* Not interested in inserted node */ |
| if (ins_doctype != NULL) |
| dom_node_unref((struct dom_node *) ins_doctype); |
| /* No longer interested in doctype */ |
| dom_node_unref((struct dom_node *) doctype); |
| } |
| static void |
| expat_xmlparser_unknown_data_handler(void *_parser, |
| const XML_Char *s, |
| int len) |
| { |
| UNUSED(_parser); |
| UNUSED(s); |
| UNUSED(len); |
| } |
| /** |
| * Create an XML parser instance |
| * |
| * \param enc Source charset, or NULL |
| * \param int_enc Desired charset of document buffer (UTF-8 or UTF-16) |
| * \param msg Informational message function |
| * \param mctx Pointer to client-specific private data |
| * \return Pointer to instance, or NULL on memory exhaustion |
| * |
| * int_enc is ignored due to it being made of bees. |
| */ |
| dom_xml_parser * |
| dom_xml_parser_create(const char *enc, const char *int_enc, |
| dom_msg msg, void *mctx, dom_document **document) |
| { |
| dom_xml_parser *parser; |
| dom_exception err; |
| UNUSED(int_enc); |
| parser = calloc(sizeof(*parser), 1); |
| if (parser == NULL) { |
| msg(DOM_MSG_CRITICAL, mctx, "No memory for parser"); |
| return NULL; |
| } |
| parser->msg = msg; |
| parser->mctx = mctx; |
| parser->parser = XML_ParserCreateNS(enc, '\n'); |
| if (parser->parser == NULL) { |
| free(parser); |
| msg(DOM_MSG_CRITICAL, mctx, "No memory for parser"); |
| return NULL; |
| } |
| parser->doc = NULL; |
| err = dom_implementation_create_document( |
| DOM_IMPLEMENTATION_XML, |
| /* namespace */ NULL, |
| /* qname */ NULL, |
| /* doctype */ NULL, |
| NULL, |
| NULL, |
| document); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed creating document"); |
| XML_ParserFree(parser->parser); |
| free(parser); |
| return NULL; |
| } |
| parser->doc = (dom_document *) dom_node_ref(*document); |
| XML_SetUserData(parser->parser, parser); |
| XML_SetElementHandler(parser->parser, |
| expat_xmlparser_start_element_handler, |
| expat_xmlparser_end_element_handler); |
| XML_SetCdataSectionHandler(parser->parser, |
| expat_xmlparser_start_cdata_handler, |
| expat_xmlparser_end_cdata_handler); |
| XML_SetCharacterDataHandler(parser->parser, |
| expat_xmlparser_cdata_handler); |
| XML_SetParamEntityParsing(parser->parser, |
| XML_PARAM_ENTITY_PARSING_ALWAYS); |
| XML_SetExternalEntityRefHandler(parser->parser, |
| expat_xmlparser_external_entity_ref_handler); |
| XML_SetCommentHandler(parser->parser, |
| expat_xmlparser_comment_handler); |
| XML_SetStartDoctypeDeclHandler(parser->parser, |
| expat_xmlparser_start_doctype_decl_handler); |
| XML_SetDefaultHandlerExpand(parser->parser, |
| expat_xmlparser_unknown_data_handler); |
| parser->current = dom_node_ref(parser->doc); |
| parser->is_cdata = false; |
| return parser; |
| } |
| /** |
| * Destroy an XML parser instance |
| * |
| * \param parser The parser instance to destroy |
| */ |
| void |
| dom_xml_parser_destroy(dom_xml_parser *parser) |
| { |
| XML_ParserFree(parser->parser); |
| if (parser->current != NULL) |
| dom_node_unref(parser->current); |
| dom_node_unref(parser->doc); |
| free(parser); |
| } |
| /** |
| * Parse a chunk of data |
| * |
| * \param parser The XML parser instance to use for parsing |
| * \param data Pointer to data chunk |
| * \param len Byte length of data chunk |
| * \return DOM_XML_OK on success, DOM_XML_EXTERNAL_ERR | <expat error> on failure |
| */ |
| dom_xml_error |
| dom_xml_parser_parse_chunk(dom_xml_parser *parser, uint8_t *data, size_t len) |
| { |
| enum XML_Status status; |
| status = XML_Parse(parser->parser, (const char *)data, len, 0); |
| if (status != XML_STATUS_OK) { |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "XML_Parse failed: %d", status); |
| return DOM_XML_EXTERNAL_ERR | status; |
| } |
| return DOM_XML_OK; |
| } |
| /** |
| * Notify parser that datastream is empty |
| * |
| * \param parser The XML parser instance to notify |
| * \return DOM_XML_OK on success, DOM_XML_EXTERNAL_ERR | <expat error> on failure |
| * |
| * This will force any remaining data through the parser |
| */ |
| dom_xml_error |
| dom_xml_parser_completed(dom_xml_parser *parser) |
| { |
| enum XML_Status status; |
| status = XML_Parse(parser->parser, "", 0, 1); |
| if (status != XML_STATUS_OK) { |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "XML_Parse failed: %d", status); |
| return DOM_XML_EXTERNAL_ERR | status; |
| } |
| return DOM_XML_OK; |
| } |
| /contrib/network/netsurf/libdom/bindings/xml/libxml_xmlparser.c |
|---|
| 0,0 → 1,1335 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #include <stdbool.h> |
| #include <string.h> |
| #include <assert.h> |
| #include <libxml/parser.h> |
| #include <libxml/SAX2.h> |
| #include <libxml/xmlerror.h> |
| #include <dom/dom.h> |
| #include <libwapcaplet/libwapcaplet.h> |
| #include "xmlerror.h" |
| #include "xmlparser.h" |
| #include "utils.h" |
| #include "core/document.h" |
| static void xml_parser_start_document(void *ctx); |
| static void xml_parser_end_document(void *ctx); |
| static void xml_parser_start_element_ns(void *ctx, const xmlChar *localname, |
| const xmlChar *prefix, const xmlChar *URI, |
| int nb_namespaces, const xmlChar **namespaces, |
| int nb_attributes, int nb_defaulted, |
| const xmlChar **attributes); |
| static void xml_parser_end_element_ns(void *ctx, const xmlChar *localname, |
| const xmlChar *prefix, const xmlChar *URI); |
| static dom_exception xml_parser_link_nodes(dom_xml_parser *parser, |
| struct dom_node *dom, xmlNodePtr xml); |
| static void xml_parser_add_node(dom_xml_parser *parser, struct dom_node *parent, |
| xmlNodePtr child); |
| static void xml_parser_add_element_node(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child); |
| static void xml_parser_add_text_node(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child); |
| static void xml_parser_add_cdata_section(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child); |
| static void xml_parser_add_entity_reference(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child); |
| static void xml_parser_add_entity(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child); |
| static void xml_parser_add_comment(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child); |
| static void xml_parser_add_document_type(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child); |
| static void xml_parser_internal_subset(void *ctx, const xmlChar *name, |
| const xmlChar *ExternalID, const xmlChar *SystemID); |
| static int xml_parser_is_standalone(void *ctx); |
| static int xml_parser_has_internal_subset(void *ctx); |
| static int xml_parser_has_external_subset(void *ctx); |
| static xmlParserInputPtr xml_parser_resolve_entity(void *ctx, |
| const xmlChar *publicId, const xmlChar *systemId); |
| static xmlEntityPtr xml_parser_get_entity(void *ctx, const xmlChar *name); |
| static void xml_parser_entity_decl(void *ctx, const xmlChar *name, |
| int type, const xmlChar *publicId, const xmlChar *systemId, |
| xmlChar *content); |
| static void xml_parser_notation_decl(void *ctx, const xmlChar *name, |
| const xmlChar *publicId, const xmlChar *systemId); |
| static void xml_parser_attribute_decl(void *ctx, const xmlChar *elem, |
| const xmlChar *fullname, int type, int def, |
| const xmlChar *defaultValue, xmlEnumerationPtr tree); |
| static void xml_parser_element_decl(void *ctx, const xmlChar *name, |
| int type, xmlElementContentPtr content); |
| static void xml_parser_unparsed_entity_decl(void *ctx, const xmlChar *name, |
| const xmlChar *publicId, const xmlChar *systemId, |
| const xmlChar *notationName); |
| static void xml_parser_set_document_locator(void *ctx, xmlSAXLocatorPtr loc); |
| static void xml_parser_reference(void *ctx, const xmlChar *name); |
| static void xml_parser_characters(void *ctx, const xmlChar *ch, int len); |
| static void xml_parser_comment(void *ctx, const xmlChar *value); |
| static xmlEntityPtr xml_parser_get_parameter_entity(void *ctx, |
| const xmlChar *name); |
| static void xml_parser_cdata_block(void *ctx, const xmlChar *value, int len); |
| static void xml_parser_external_subset(void *ctx, const xmlChar *name, |
| const xmlChar *ExternalID, const xmlChar *SystemID); |
| /** |
| * libdom XML parser object |
| */ |
| struct dom_xml_parser { |
| xmlParserCtxtPtr xml_ctx; /**< libxml parser context */ |
| struct dom_document *doc; /**< DOM Document we're building */ |
| dom_string *udkey; /**< Key for DOM node user data */ |
| dom_msg msg; /**< Informational message function */ |
| void *mctx; /**< Pointer to client data */ |
| }; |
| /** |
| * SAX callback dispatch table |
| */ |
| static xmlSAXHandler sax_handler = { |
| .internalSubset = xml_parser_internal_subset, |
| .isStandalone = xml_parser_is_standalone, |
| .hasInternalSubset = xml_parser_has_internal_subset, |
| .hasExternalSubset = xml_parser_has_external_subset, |
| .resolveEntity = xml_parser_resolve_entity, |
| .getEntity = xml_parser_get_entity, |
| .entityDecl = xml_parser_entity_decl, |
| .notationDecl = xml_parser_notation_decl, |
| .attributeDecl = xml_parser_attribute_decl, |
| .elementDecl = xml_parser_element_decl, |
| .unparsedEntityDecl = xml_parser_unparsed_entity_decl, |
| .setDocumentLocator = xml_parser_set_document_locator, |
| .startDocument = xml_parser_start_document, |
| .endDocument = xml_parser_end_document, |
| .startElement = NULL, |
| .endElement = NULL, |
| .reference = xml_parser_reference, |
| .characters = xml_parser_characters, |
| .ignorableWhitespace = xml_parser_characters, |
| .processingInstruction = NULL, |
| .comment = xml_parser_comment, |
| .warning = NULL, |
| .error = NULL, |
| .fatalError = NULL, |
| .getParameterEntity = xml_parser_get_parameter_entity, |
| .cdataBlock = xml_parser_cdata_block, |
| .externalSubset = xml_parser_external_subset, |
| .initialized = XML_SAX2_MAGIC, |
| ._private = NULL, |
| .startElementNs = xml_parser_start_element_ns, |
| .endElementNs = xml_parser_end_element_ns, |
| .serror = NULL |
| }; |
| static void *dom_xml_alloc(void *ptr, size_t len, void *pw) |
| { |
| UNUSED(pw); |
| if (ptr == NULL) |
| return len > 0 ? malloc(len) : NULL; |
| if (len == 0) { |
| free(ptr); |
| return NULL; |
| } |
| return realloc(ptr, len); |
| } |
| /** |
| * Create an XML parser instance |
| * |
| * \param enc Source charset, or NULL |
| * \param int_enc Desired charset of document buffer (UTF-8 or UTF-16) |
| * \param msg Informational message function |
| * \param mctx Pointer to client-specific private data |
| * \return Pointer to instance, or NULL on memory exhaustion |
| * |
| * Neither ::enc nor ::int_enc are used here. |
| * libxml only supports a UTF-8 document buffer and forcibly setting the |
| * parser encoding is not yet implemented |
| */ |
| dom_xml_parser *dom_xml_parser_create(const char *enc, const char *int_enc, |
| dom_msg msg, void *mctx, dom_document **document) |
| { |
| dom_xml_parser *parser; |
| dom_exception err; |
| int ret; |
| UNUSED(enc); |
| UNUSED(int_enc); |
| parser = dom_xml_alloc(NULL, sizeof(dom_xml_parser), NULL); |
| if (parser == NULL) { |
| msg(DOM_MSG_CRITICAL, mctx, "No memory for parser"); |
| return NULL; |
| } |
| parser->xml_ctx = |
| xmlCreatePushParserCtxt(&sax_handler, parser, "", 0, NULL); |
| if (parser->xml_ctx == NULL) { |
| dom_xml_alloc(parser, 0, NULL); |
| msg(DOM_MSG_CRITICAL, mctx, "Failed to create XML parser"); |
| return NULL; |
| } |
| /* Set options of parsing context */ |
| ret = xmlCtxtUseOptions(parser->xml_ctx, XML_PARSE_DTDATTR | |
| XML_PARSE_DTDLOAD); |
| if (ret != 0) { |
| xmlFreeParserCtxt(parser->xml_ctx); |
| dom_xml_alloc(parser, 0, NULL); |
| msg(DOM_MSG_CRITICAL, mctx, "Failed setting parser options"); |
| return NULL; |
| } |
| /* Create key for user data registration */ |
| err = dom_string_create((const uint8_t *) "__xmlnode", |
| SLEN("__xmlnode"), &parser->udkey); |
| if (err != DOM_NO_ERR) { |
| xmlFreeParserCtxt(parser->xml_ctx); |
| dom_xml_alloc(parser, 0, NULL); |
| msg(DOM_MSG_CRITICAL, mctx, "No memory for userdata key"); |
| return NULL; |
| } |
| err = dom_implementation_create_document( |
| DOM_IMPLEMENTATION_XML, |
| /* namespace */ NULL, |
| /* qname */ NULL, |
| /* doctype */ NULL, |
| NULL, |
| NULL, |
| document); |
| if (err != DOM_NO_ERR) { |
| xmlFreeParserCtxt(parser->xml_ctx); |
| dom_string_unref(parser->udkey); |
| dom_xml_alloc(parser, 0, NULL); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed creating document"); |
| return NULL; |
| } |
| parser->doc = (dom_document *) dom_node_ref(*document); |
| parser->msg = msg; |
| parser->mctx = mctx; |
| return parser; |
| } |
| /** |
| * Destroy an XML parser instance |
| * |
| * \param parser The parser instance to destroy |
| */ |
| void dom_xml_parser_destroy(dom_xml_parser *parser) |
| { |
| dom_string_unref(parser->udkey); |
| dom_node_unref(parser->doc); |
| xmlFreeDoc(parser->xml_ctx->myDoc); |
| xmlFreeParserCtxt(parser->xml_ctx); |
| dom_xml_alloc(parser, 0, NULL); |
| } |
| /** |
| * Parse a chunk of data |
| * |
| * \param parser The XML parser instance to use for parsing |
| * \param data Pointer to data chunk |
| * \param len Byte length of data chunk |
| * \return DOM_XML_OK on success, DOM_XML_EXTERNAL_ERR | <libxml error> on failure |
| */ |
| dom_xml_error dom_xml_parser_parse_chunk(dom_xml_parser *parser, |
| uint8_t *data, size_t len) |
| { |
| xmlParserErrors err; |
| err = xmlParseChunk(parser->xml_ctx, (char *) data, len, 0); |
| if (err != XML_ERR_OK) { |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "xmlParseChunk failed: %d", err); |
| return DOM_XML_EXTERNAL_ERR | err; |
| } |
| return DOM_XML_OK; |
| } |
| /** |
| * Notify parser that datastream is empty |
| * |
| * \param parser The XML parser instance to notify |
| * \return DOM_XML_OK on success, DOM_XML_EXTERNAL_ERR | <libxml error> on failure |
| * |
| * This will force any remaining data through the parser |
| */ |
| dom_xml_error dom_xml_parser_completed(dom_xml_parser *parser) |
| { |
| xmlParserErrors err; |
| err = xmlParseChunk(parser->xml_ctx, "", 0, 1); |
| if (err != XML_ERR_OK) { |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "xmlParseChunk failed: %d", err); |
| return DOM_XML_EXTERNAL_ERR | err; |
| } |
| return DOM_XML_OK; |
| } |
| /** |
| * Handle a document start SAX event |
| * |
| * \param ctx The callback context |
| */ |
| void xml_parser_start_document(void *ctx) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| dom_exception err; |
| /* Invoke libxml2's default behaviour */ |
| xmlSAX2StartDocument(parser->xml_ctx); |
| /* Link nodes together */ |
| err = xml_parser_link_nodes(parser, (struct dom_node *) parser->doc, |
| (xmlNodePtr) parser->xml_ctx->myDoc); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_WARNING, parser->mctx, |
| "Not able to link document nodes"); |
| } |
| } |
| /** |
| * Handle a document end SAX event |
| * |
| * \param ctx The callback context |
| */ |
| void xml_parser_end_document(void *ctx) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlNodePtr node; |
| xmlNodePtr n; |
| dom_exception err; |
| /* Invoke libxml2's default behaviour */ |
| xmlSAX2EndDocument(parser->xml_ctx); |
| /* If there is no document, we can't do anything */ |
| if (parser->doc == NULL) { |
| parser->msg(DOM_MSG_WARNING, parser->mctx, |
| "No document in end_document"); |
| return; |
| } |
| /* We need to mirror any child nodes at the end of the list of |
| * children which occur after the last Element node in the list */ |
| /* Get XML node */ |
| err = dom_node_get_user_data((struct dom_node *) parser->doc, |
| parser->udkey, (void **) (void *) &node); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_WARNING, parser->mctx, |
| "Failed finding XML node"); |
| return; |
| } |
| /* Find last Element node, if any */ |
| for (n = node->last; n != NULL; n = n->prev) { |
| if (n->type == XML_ELEMENT_NODE) |
| break; |
| } |
| if (n == NULL) { |
| /* No Element node found; entire list needs mirroring */ |
| n = node->children; |
| } else { |
| /* Found last Element; skip over it */ |
| n = n->next; |
| } |
| /* Now, mirror nodes in the DOM */ |
| for (; n != NULL; n = n->next) { |
| xml_parser_add_node(parser, |
| (struct dom_node *) node->_private, n); |
| } |
| } |
| /** |
| * Handle an element open SAX event |
| * |
| * \param ctx The callback context |
| * \param localname The local name of the element |
| * \param prefix The element namespace prefix |
| * \param URI The element namespace URI |
| * \param nb_namespaces The number of namespace definitions |
| * \param namespaces Array of nb_namespaces prefix/URI pairs |
| * \param nb_attributes The total number of attributes |
| * \param nb_defaulted The number of defaulted attributes |
| * \param attributes Array of nb_attributes attribute values |
| * |
| * The number of non-defaulted attributes is ::nb_attributes - ::nb_defaulted |
| * The defaulted attributes are at the end of the array ::attributes. |
| */ |
| void xml_parser_start_element_ns(void *ctx, const xmlChar *localname, |
| const xmlChar *prefix, const xmlChar *URI, |
| int nb_namespaces, const xmlChar **namespaces, |
| int nb_attributes, int nb_defaulted, |
| const xmlChar **attributes) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlNodePtr parent = parser->xml_ctx->node; |
| /* Invoke libxml2's default behaviour */ |
| xmlSAX2StartElementNs(parser->xml_ctx, localname, prefix, URI, |
| nb_namespaces, namespaces, nb_attributes, |
| nb_defaulted, attributes); |
| /* If there is no document, we can't do anything */ |
| if (parser->doc == NULL) { |
| parser->msg(DOM_MSG_WARNING, parser->mctx, |
| "No document in start_element_ns"); |
| return; |
| } |
| if (parent == NULL) { |
| /* No parent; use document */ |
| parent = (xmlNodePtr) parser->xml_ctx->myDoc; |
| } |
| if (parent->type == XML_DOCUMENT_NODE || |
| parent->type == XML_ELEMENT_NODE) { |
| /* Mirror in the DOM all children of the parent node |
| * between the previous Element child (or the start, |
| * whichever is encountered first) and the Element |
| * just created */ |
| xmlNodePtr n; |
| /* Find previous element node, if any */ |
| for (n = parser->xml_ctx->node->prev; n != NULL; |
| n = n->prev) { |
| if (n->type == XML_ELEMENT_NODE) |
| break; |
| } |
| if (n == NULL) { |
| /* No previous Element; use parent's children */ |
| n = parent->children; |
| } else { |
| /* Previous Element; skip over it */ |
| n = n->next; |
| } |
| /* Now, mirror nodes in the DOM */ |
| for (; n != parser->xml_ctx->node; n = n->next) { |
| xml_parser_add_node(parser, |
| (struct dom_node *) parent->_private, |
| n); |
| } |
| } |
| /* Mirror the created node and its attributes in the DOM */ |
| xml_parser_add_node(parser, (struct dom_node *) parent->_private, |
| parser->xml_ctx->node); |
| } |
| /** |
| * Handle an element close SAX event |
| * |
| * \param ctx The callback context |
| * \param localname The local name of the element |
| * \param prefix The element namespace prefix |
| * \param URI The element namespace URI |
| */ |
| void xml_parser_end_element_ns(void *ctx, const xmlChar *localname, |
| const xmlChar *prefix, const xmlChar *URI) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlNodePtr node = parser->xml_ctx->node; |
| xmlNodePtr n; |
| /* Invoke libxml2's default behaviour */ |
| xmlSAX2EndElementNs(parser->xml_ctx, localname, prefix, URI); |
| /* If there is no document, we can't do anything */ |
| if (parser->doc == NULL) { |
| parser->msg(DOM_MSG_WARNING, parser->mctx, |
| "No document in end_element_ns"); |
| return; |
| } |
| /* If node wasn't linked, we can't do anything */ |
| if (node->_private == NULL) { |
| parser->msg(DOM_MSG_WARNING, parser->mctx, |
| "Node '%s' not linked", node->name); |
| return; |
| } |
| /* We need to mirror any child nodes at the end of the list of |
| * children which occur after the last Element node in the list */ |
| /* Find last Element node, if any */ |
| for (n = node->last; n != NULL; n = n->prev) { |
| if (n->type == XML_ELEMENT_NODE) |
| break; |
| } |
| if (n == NULL) { |
| /* No Element node found; entire list needs mirroring */ |
| n = node->children; |
| } else { |
| /* Found last Element; skip over it */ |
| n = n->next; |
| } |
| /* Now, mirror nodes in the DOM */ |
| for (; n != NULL; n = n->next) { |
| xml_parser_add_node(parser, |
| (struct dom_node *) node->_private, n); |
| } |
| } |
| /** |
| * Link a DOM and XML node together |
| * |
| * \param parser The parser context |
| * \param dom The DOM node |
| * \param xml The XML node |
| * \return DOM_NO_ERR on success, appropriate error otherwise |
| */ |
| dom_exception xml_parser_link_nodes(dom_xml_parser *parser, |
| struct dom_node *dom, xmlNodePtr xml) |
| { |
| void *prev_data; |
| dom_exception err; |
| /* Register XML node as user data for DOM node */ |
| err = dom_node_set_user_data(dom, parser->udkey, xml, NULL, |
| &prev_data); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "Failed setting user data: %d", err); |
| return err; |
| } |
| /* Register DOM node with the XML node */ |
| xml->_private = dom; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Add a node to the DOM |
| * |
| * \param parser The parser context |
| * \param parent The parent DOM node |
| * \param child The xmlNode to mirror in the DOM as a child of parent |
| */ |
| void xml_parser_add_node(dom_xml_parser *parser, struct dom_node *parent, |
| xmlNodePtr child) |
| { |
| static const char *node_types[] = { |
| "THIS_IS_NOT_A_NODE", |
| "XML_ELEMENT_NODE", |
| "XML_ATTRIBUTE_NODE", |
| "XML_TEXT_NODE", |
| "XML_CDATA_SECTION_NODE", |
| "XML_ENTITY_REF_NODE", |
| "XML_ENTITY_NODE", |
| "XML_PI_NODE", |
| "XML_COMMENT_NODE", |
| "XML_DOCUMENT_NODE", |
| "XML_DOCUMENT_TYPE_NODE", |
| "XML_DOCUMENT_FRAG_NODE", |
| "XML_NOTATION_NODE", |
| "XML_HTML_DOCUMENT_NODE", |
| "XML_DTD_NODE", |
| "XML_ELEMENT_DECL", |
| "XML_ATTRIBUTE_DECL", |
| "XML_ENTITY_DECL", |
| "XML_NAMESPACE_DECL", |
| "XML_XINCLUDE_START", |
| "XML_XINCLUDE_END", |
| "XML_DOCB_DOCUMENT_NODE" |
| }; |
| switch (child->type) { |
| case XML_ELEMENT_NODE: |
| xml_parser_add_element_node(parser, parent, child); |
| break; |
| case XML_TEXT_NODE: |
| xml_parser_add_text_node(parser, parent, child); |
| break; |
| case XML_CDATA_SECTION_NODE: |
| xml_parser_add_cdata_section(parser, parent, child); |
| break; |
| case XML_ENTITY_REF_NODE: |
| xml_parser_add_entity_reference(parser, parent, child); |
| break; |
| case XML_COMMENT_NODE: |
| xml_parser_add_comment(parser, parent, child); |
| break; |
| case XML_DTD_NODE: |
| xml_parser_add_document_type(parser, parent, child); |
| break; |
| case XML_ENTITY_DECL: |
| xml_parser_add_entity(parser, parent, child); |
| break; |
| default: |
| parser->msg(DOM_MSG_NOTICE, parser->mctx, |
| "Unsupported node type: %s", |
| node_types[child->type]); |
| } |
| } |
| /** |
| * Add an element node to the DOM |
| * |
| * \param parser The parser context |
| * \param parent The parent DOM node |
| * \param child The xmlNode to mirror in the DOM as a child of parent |
| */ |
| void xml_parser_add_element_node(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child) |
| { |
| struct dom_element *el, *ins_el = NULL; |
| xmlAttrPtr a; |
| dom_exception err; |
| /* Create the element node */ |
| if (child->ns == NULL) { |
| /* No namespace */ |
| dom_string *tag_name; |
| /* Create tag name DOM string */ |
| err = dom_string_create(child->name, |
| strlen((const char *) child->name), &tag_name); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for tag name"); |
| return; |
| } |
| /* Create element node */ |
| err = dom_document_create_element(parser->doc, |
| tag_name, &el); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(tag_name); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed creating element '%s'", |
| child->name); |
| return; |
| } |
| /* No longer need tag name */ |
| dom_string_unref(tag_name); |
| } else { |
| /* Namespace */ |
| dom_string *namespace; |
| dom_string *qname; |
| size_t qnamelen = (child->ns->prefix != NULL ? |
| strlen((const char *) child->ns->prefix) : 0) + |
| (child->ns->prefix != NULL ? 1 : 0) /* ':' */ + |
| strlen((const char *) child->name); |
| uint8_t qnamebuf[qnamelen + 1 /* '\0' */]; |
| /* Create namespace DOM string */ |
| err = dom_string_create( |
| child->ns->href, |
| strlen((const char *) child->ns->href), |
| &namespace); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for namespace"); |
| return; |
| } |
| /* QName is "prefix:localname", |
| * or "localname" if there is no prefix */ |
| sprintf((char *) qnamebuf, "%s%s%s", |
| child->ns->prefix != NULL ? |
| (const char *) child->ns->prefix : "", |
| child->ns->prefix != NULL ? ":" : "", |
| (const char *) child->name); |
| /* Create qname DOM string */ |
| err = dom_string_create( |
| qnamebuf, |
| qnamelen, |
| &qname); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(namespace); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for qname"); |
| return; |
| } |
| /* Create element node */ |
| err = dom_document_create_element_ns(parser->doc, |
| namespace, qname, &el); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(namespace); |
| dom_string_unref(qname); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed creating element '%s'", |
| qnamebuf); |
| return; |
| } |
| /* No longer need namespace / qname */ |
| dom_string_unref(namespace); |
| dom_string_unref(qname); |
| } |
| /* Add attributes to created element */ |
| for (a = child->properties; a != NULL; a = a->next) { |
| struct dom_attr *attr, *prev_attr; |
| xmlNodePtr c; |
| /* Create attribute node */ |
| if (a->ns == NULL) { |
| /* Attribute has no namespace */ |
| dom_string *name; |
| /* Create attribute name DOM string */ |
| err = dom_string_create( |
| a->name, |
| strlen((const char *) a->name), |
| &name); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for attribute name"); |
| goto cleanup; |
| } |
| /* Create attribute */ |
| err = dom_document_create_attribute(parser->doc, |
| name, &attr); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(name); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed creating attribute \ |
| '%s'", a->name); |
| goto cleanup; |
| } |
| /* No longer need attribute name */ |
| dom_string_unref(name); |
| } else { |
| /* Attribute has namespace */ |
| dom_string *namespace; |
| dom_string *qname; |
| size_t qnamelen = (a->ns->prefix != NULL ? |
| strlen((const char *) a->ns->prefix) : 0) + |
| (a->ns->prefix != NULL ? 1 : 0) /* ':' */ + |
| strlen((const char *) a->name); |
| uint8_t qnamebuf[qnamelen + 1 /* '\0' */]; |
| /* Create namespace DOM string */ |
| err = dom_string_create( |
| a->ns->href, |
| strlen((const char *) a->ns->href), |
| &namespace); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for namespace"); |
| return; |
| } |
| /* QName is "prefix:localname", |
| * or "localname" if there is no prefix */ |
| sprintf((char *) qnamebuf, "%s%s%s", |
| a->ns->prefix != NULL ? |
| (const char *) a->ns->prefix : "", |
| a->ns->prefix != NULL ? ":" : "", |
| (const char *) a->name); |
| /* Create qname DOM string */ |
| err = dom_string_create( |
| qnamebuf, |
| qnamelen, |
| &qname); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(namespace); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for qname"); |
| return; |
| } |
| /* Create attribute */ |
| err = dom_document_create_attribute_ns(parser->doc, |
| namespace, qname, &attr); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(namespace); |
| dom_string_unref(qname); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed creating attribute \ |
| '%s'", qnamebuf); |
| return; |
| } |
| /* No longer need namespace / qname */ |
| dom_string_unref(namespace); |
| dom_string_unref(qname); |
| } |
| /* Clone subtree (attribute value) */ |
| for (c = a->children; c != NULL; c = c->next) { |
| xml_parser_add_node(parser, |
| (struct dom_node *) attr, c); |
| } |
| /* Link nodes together */ |
| err = xml_parser_link_nodes(parser, |
| (struct dom_node *) attr, (xmlNodePtr) a); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) attr); |
| goto cleanup; |
| } |
| if (a->ns == NULL) { |
| /* And add attribute to the element */ |
| err = dom_element_set_attribute_node(el, attr, |
| &prev_attr); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) attr); |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "Failed attaching attribute \ |
| '%s'", a->name); |
| goto cleanup; |
| } |
| } else { |
| err = dom_element_set_attribute_node_ns(el, attr, |
| &prev_attr); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) attr); |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "Failed attaching attribute \ |
| '%s'", a->name); |
| goto cleanup; |
| } |
| } |
| /* We're not interested in the previous attribute (if any) */ |
| if (prev_attr != NULL && prev_attr != attr) |
| dom_node_unref((struct dom_node *) prev_attr); |
| /* We're no longer interested in the attribute node */ |
| dom_node_unref((struct dom_node *) attr); |
| } |
| /* Append element to parent */ |
| err = dom_node_append_child(parent, (struct dom_node *) el, |
| (struct dom_node **) (void *) &ins_el); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "Failed attaching element '%s'", |
| child->name); |
| goto cleanup; |
| } |
| /* We're not interested in the inserted element */ |
| if (ins_el != NULL) |
| dom_node_unref((struct dom_node *) ins_el); |
| /* Link nodes together */ |
| err = xml_parser_link_nodes(parser, (struct dom_node *) el, |
| child); |
| if (err != DOM_NO_ERR) { |
| goto cleanup; |
| } |
| /* No longer interested in element node */ |
| dom_node_unref((struct dom_node *) el); |
| return; |
| cleanup: |
| /* No longer want node (any attributes attached to it |
| * will be cleaned up with it) */ |
| dom_node_unref((struct dom_node *) el); |
| return; |
| } |
| /** |
| * Add a text node to the DOM |
| * |
| * \param parser The parser context |
| * \param parent The parent DOM node |
| * \param child The xmlNode to mirror in the DOM as a child of parent |
| */ |
| void xml_parser_add_text_node(dom_xml_parser *parser, struct dom_node *parent, |
| xmlNodePtr child) |
| { |
| struct dom_text *text, *ins_text = NULL; |
| dom_string *data; |
| dom_exception err; |
| /* Create DOM string data for text node */ |
| err = dom_string_create(child->content, |
| strlen((const char *) child->content), &data); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for text node contents "); |
| return; |
| } |
| /* Create text node */ |
| err = dom_document_create_text_node(parser->doc, data, &text); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(data); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for text node"); |
| return; |
| } |
| /* No longer need data */ |
| dom_string_unref(data); |
| /* Append text node to parent */ |
| err = dom_node_append_child(parent, (struct dom_node *) text, |
| (struct dom_node **) (void *) &ins_text); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) text); |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "Failed attaching text node"); |
| return; |
| } |
| /* We're not interested in the inserted text node */ |
| if (ins_text != NULL) |
| dom_node_unref((struct dom_node *) ins_text); |
| /* Link nodes together */ |
| err = xml_parser_link_nodes(parser, (struct dom_node *) text, |
| child); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) text); |
| return; |
| } |
| /* No longer interested in text node */ |
| dom_node_unref((struct dom_node *) text); |
| } |
| /** |
| * Add a cdata section to the DOM |
| * |
| * \param parser The parser context |
| * \param parent The parent DOM node |
| * \param child The xmlNode to mirror in the DOM as a child of parent |
| */ |
| void xml_parser_add_cdata_section(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child) |
| { |
| struct dom_cdata_section *cdata, *ins_cdata = NULL; |
| dom_string *data; |
| dom_exception err; |
| /* Create DOM string data for cdata section */ |
| err = dom_string_create(child->content, |
| strlen((const char *) child->content), &data); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for cdata section contents"); |
| return; |
| } |
| /* Create cdata section */ |
| err = dom_document_create_cdata_section(parser->doc, data, &cdata); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(data); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for cdata section"); |
| return; |
| } |
| /* No longer need data */ |
| dom_string_unref(data); |
| /* Append cdata section to parent */ |
| err = dom_node_append_child(parent, (struct dom_node *) cdata, |
| (struct dom_node **) (void *) &ins_cdata); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) cdata); |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "Failed attaching cdata section"); |
| return; |
| } |
| /* We're not interested in the inserted cdata section */ |
| if (ins_cdata != NULL) |
| dom_node_unref((struct dom_node *) ins_cdata); |
| /* Link nodes together */ |
| err = xml_parser_link_nodes(parser, (struct dom_node *) cdata, |
| child); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) cdata); |
| return; |
| } |
| /* No longer interested in cdata section */ |
| dom_node_unref((struct dom_node *) cdata); |
| } |
| /** |
| * Add an entity reference to the DOM |
| * |
| * \param parser The parser context |
| * \param parent The parent DOM node |
| * \param child The xmlNode to mirror in the DOM as a child of parent |
| */ |
| void xml_parser_add_entity_reference(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child) |
| { |
| struct dom_entity_reference *entity, *ins_entity = NULL; |
| dom_string *name; |
| xmlNodePtr c; |
| dom_exception err; |
| /* Create name of entity reference */ |
| err = dom_string_create(child->name, |
| strlen((const char *) child->name), &name); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for entity reference name"); |
| return; |
| } |
| /* Create text node */ |
| err = dom_document_create_entity_reference(parser->doc, name, |
| &entity); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(name); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for entity reference"); |
| return; |
| } |
| /* No longer need name */ |
| dom_string_unref(name); |
| /* Mirror subtree (reference value) */ |
| for (c = child->children; c != NULL; c = c->next) { |
| xml_parser_add_node(parser, (struct dom_node *) entity, c); |
| } |
| /* Append entity reference to parent */ |
| err = dom_node_append_child(parent, (struct dom_node *) entity, |
| (struct dom_node **) (void *) &ins_entity); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) entity); |
| parser->msg(DOM_MSG_ERROR, parser->mctx, |
| "Failed attaching entity reference"); |
| return; |
| } |
| /* We're not interested in the inserted entity reference */ |
| if (ins_entity != NULL) |
| dom_node_unref((struct dom_node *) ins_entity); |
| /* Link nodes together */ |
| err = xml_parser_link_nodes(parser, (struct dom_node *) entity, |
| child); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) entity); |
| return; |
| } |
| /* No longer interested in entity reference */ |
| dom_node_unref((struct dom_node *) entity); |
| } |
| static void xml_parser_add_entity(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child) |
| { |
| UNUSED(parser); |
| UNUSED(parent); |
| UNUSED(child); |
| } |
| /** |
| * Add a comment to the DOM |
| * |
| * \param parser The parser context |
| * \param parent The parent DOM node |
| * \param child The xmlNode to mirror in the DOM as a child of parent |
| */ |
| void xml_parser_add_comment(dom_xml_parser *parser, struct dom_node *parent, |
| xmlNodePtr child) |
| { |
| struct dom_comment *comment, *ins_comment = NULL; |
| dom_string *data; |
| dom_exception err; |
| /* Create DOM string data for comment */ |
| err = dom_string_create(child->content, |
| strlen((const char *) child->content), &data); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for comment data"); |
| return; |
| } |
| /* Create comment */ |
| err = dom_document_create_comment(parser->doc, data, &comment); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(data); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "No memory for comment node"); |
| return; |
| } |
| /* No longer need data */ |
| dom_string_unref(data); |
| /* Append comment to parent */ |
| err = dom_node_append_child(parent, (struct dom_node *) comment, |
| (struct dom_node **) (void *) &ins_comment); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) comment); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed attaching comment node"); |
| return; |
| } |
| /* We're not interested in the inserted comment */ |
| if (ins_comment != NULL) |
| dom_node_unref((struct dom_node *) ins_comment); |
| /* Link nodes together */ |
| err = xml_parser_link_nodes(parser, (struct dom_node *) comment, |
| child); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) comment); |
| return; |
| } |
| /* No longer interested in comment */ |
| dom_node_unref((struct dom_node *) comment); |
| } |
| /** |
| * Add a document type to the DOM |
| * |
| * \param parser The parser context |
| * \param parent The parent DOM node |
| * \param child The xmlNode to mirror in the DOM as a child of parent |
| */ |
| void xml_parser_add_document_type(dom_xml_parser *parser, |
| struct dom_node *parent, xmlNodePtr child) |
| { |
| xmlDtdPtr dtd = (xmlDtdPtr) child; |
| struct dom_document_type *doctype, *ins_doctype = NULL; |
| const char *qname, *public_id, *system_id; |
| dom_exception err; |
| /* Create qname for doctype */ |
| qname = (const char *) dtd->name; |
| /* Create public ID for doctype */ |
| public_id = dtd->ExternalID != NULL ? |
| (const char *) dtd->ExternalID : ""; |
| /* Create system ID for doctype */ |
| system_id = dtd->SystemID != NULL ? |
| (const char *) dtd->SystemID : ""; |
| /* Create doctype */ |
| err = dom_implementation_create_document_type( |
| qname, public_id, system_id, |
| &doctype); |
| if (err != DOM_NO_ERR) { |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed to create document type"); |
| return; |
| } |
| /* Add doctype to document */ |
| err = dom_node_append_child(parent, (struct dom_node *) doctype, |
| (struct dom_node **) (void *) &ins_doctype); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) doctype); |
| parser->msg(DOM_MSG_CRITICAL, parser->mctx, |
| "Failed attaching doctype"); |
| return; |
| } |
| /* Not interested in inserted node */ |
| if (ins_doctype != NULL) |
| dom_node_unref((struct dom_node *) ins_doctype); |
| /* Link nodes together */ |
| err = xml_parser_link_nodes(parser, (struct dom_node *) doctype, |
| child); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) doctype); |
| return; |
| } |
| /* No longer interested in doctype */ |
| dom_node_unref((struct dom_node *) doctype); |
| } |
| /* ------------------------------------------------------------------------*/ |
| void xml_parser_internal_subset(void *ctx, const xmlChar *name, |
| const xmlChar *ExternalID, const xmlChar *SystemID) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2InternalSubset(parser->xml_ctx, name, ExternalID, SystemID); |
| } |
| int xml_parser_is_standalone(void *ctx) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| return xmlSAX2IsStandalone(parser->xml_ctx); |
| } |
| int xml_parser_has_internal_subset(void *ctx) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| return xmlSAX2HasInternalSubset(parser->xml_ctx); |
| } |
| int xml_parser_has_external_subset(void *ctx) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| return xmlSAX2HasExternalSubset(parser->xml_ctx); |
| } |
| xmlParserInputPtr xml_parser_resolve_entity(void *ctx, |
| const xmlChar *publicId, const xmlChar *systemId) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| return xmlSAX2ResolveEntity(parser->xml_ctx, publicId, systemId); |
| } |
| xmlEntityPtr xml_parser_get_entity(void *ctx, const xmlChar *name) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| return xmlSAX2GetEntity(parser->xml_ctx, name); |
| } |
| void xml_parser_entity_decl(void *ctx, const xmlChar *name, |
| int type, const xmlChar *publicId, const xmlChar *systemId, |
| xmlChar *content) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2EntityDecl(parser->xml_ctx, name, type, publicId, systemId, |
| content); |
| } |
| void xml_parser_notation_decl(void *ctx, const xmlChar *name, |
| const xmlChar *publicId, const xmlChar *systemId) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2NotationDecl(parser->xml_ctx, name, publicId, systemId); |
| } |
| void xml_parser_attribute_decl(void *ctx, const xmlChar *elem, |
| const xmlChar *fullname, int type, int def, |
| const xmlChar *defaultValue, xmlEnumerationPtr tree) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2AttributeDecl(parser->xml_ctx, elem, fullname, type, def, |
| defaultValue, tree); |
| } |
| void xml_parser_element_decl(void *ctx, const xmlChar *name, |
| int type, xmlElementContentPtr content) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2ElementDecl(parser->xml_ctx, name, type, content); |
| } |
| void xml_parser_unparsed_entity_decl(void *ctx, const xmlChar *name, |
| const xmlChar *publicId, const xmlChar *systemId, |
| const xmlChar *notationName) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2UnparsedEntityDecl(parser->xml_ctx, name, publicId, |
| systemId, notationName); |
| } |
| void xml_parser_set_document_locator(void *ctx, xmlSAXLocatorPtr loc) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2SetDocumentLocator(parser->xml_ctx, loc); |
| } |
| void xml_parser_reference(void *ctx, const xmlChar *name) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2Reference(parser->xml_ctx, name); |
| } |
| void xml_parser_characters(void *ctx, const xmlChar *ch, int len) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2Characters(parser->xml_ctx, ch, len); |
| } |
| void xml_parser_comment(void *ctx, const xmlChar *value) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2Comment(parser->xml_ctx, value); |
| } |
| xmlEntityPtr xml_parser_get_parameter_entity(void *ctx, const xmlChar *name) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| return xmlSAX2GetParameterEntity(parser->xml_ctx, name); |
| } |
| void xml_parser_cdata_block(void *ctx, const xmlChar *value, int len) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2CDataBlock(parser->xml_ctx, value, len); |
| } |
| void xml_parser_external_subset(void *ctx, const xmlChar *name, |
| const xmlChar *ExternalID, const xmlChar *SystemID) |
| { |
| dom_xml_parser *parser = (dom_xml_parser *) ctx; |
| xmlSAX2ExternalSubset(parser->xml_ctx, name, ExternalID, SystemID); |
| } |
| /contrib/network/netsurf/libdom/bindings/xml/utils.h |
|---|
| 0,0 → 1,28 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef xml_utils_h_ |
| #define xml_utils_h_ |
| #ifndef max |
| #define max(a,b) ((a)>(b)?(a):(b)) |
| #endif |
| #ifndef min |
| #define min(a,b) ((a)<(b)?(a):(b)) |
| #endif |
| #ifndef SLEN |
| /* Calculate length of a string constant */ |
| #define SLEN(s) (sizeof((s)) - 1) /* -1 for '\0' */ |
| #endif |
| #ifndef UNUSED |
| #define UNUSED(x) ((x)=(x)) |
| #endif |
| #endif |
| /contrib/network/netsurf/libdom/bindings/xml/xmlerror.h |
|---|
| 0,0 → 1,19 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef xml_xmlerror_h_ |
| #define xml_xmlerror_h_ |
| typedef enum { |
| DOM_XML_OK = 0, |
| DOM_XML_NOMEM = 1, |
| DOM_XML_EXTERNAL_ERR = (1<<16), |
| } dom_xml_error; |
| #endif |
| /contrib/network/netsurf/libdom/bindings/xml/xmlparser.h |
|---|
| 0,0 → 1,34 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef xml_xmlparser_h_ |
| #define xml_xmlparser_h_ |
| #include <stddef.h> |
| #include <inttypes.h> |
| #include <dom/dom.h> |
| #include "xmlerror.h" |
| typedef struct dom_xml_parser dom_xml_parser; |
| /* Create an XML parser instance */ |
| dom_xml_parser *dom_xml_parser_create(const char *enc, const char *int_enc, |
| dom_msg msg, void *mctx, dom_document **document); |
| /* Destroy an XML parser instance */ |
| void dom_xml_parser_destroy(dom_xml_parser *parser); |
| /* Parse a chunk of data */ |
| dom_xml_error dom_xml_parser_parse_chunk(dom_xml_parser *parser, |
| uint8_t *data, size_t len); |
| /* Notify parser that datastream is empty */ |
| dom_xml_error dom_xml_parser_completed(dom_xml_parser *parser); |
| #endif |
| /contrib/network/netsurf/libdom/.gitignore |
|---|
| 0,0 → 1,7 |
| Makefile.config.override |
| build-* |
| build/docs |
| examples/dom-structure-dump |
| test/level*.c |
| test/INDEX |
| *~ |
| /contrib/network/netsurf/libdom/COPYING |
|---|
| 0,0 → 1,19 |
| Copyright (C) 2007 J-M Bell |
| Permission is hereby granted, free of charge, to any person obtaining a copy |
| of this software and associated documentation files (the "Software"), to deal |
| in the Software without restriction, including without limitation the rights |
| to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| copies of the Software, and to permit persons to whom the Software is |
| furnished to do so, subject to the following conditions: |
| * The above copyright notice and this permission notice shall be included in |
| all copies or substantial portions of the Software. |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| THE SOFTWARE. |
| /contrib/network/netsurf/libdom/Makefile |
|---|
| 0,0 → 1,109 |
| # Component settings |
| COMPONENT := dom |
| COMPONENT_VERSION := 0.0.1 |
| # Default to a static library |
| COMPONENT_TYPE ?= lib-static |
| # Setup the tooling |
| PREFIX ?= /opt/netsurf |
| NSSHARED ?= $(PREFIX)/share/netsurf-buildsystem |
| include $(NSSHARED)/makefiles/Makefile.tools |
| TESTRUNNER := $(PERL) $(NSTESTTOOLS)/testrunner.pl |
| # Toolchain flags |
| WARNFLAGS := -Wall -W -Wundef -Wpointer-arith -Wcast-align \ |
| -Wwrite-strings -Wstrict-prototypes -Wmissing-prototypes \ |
| -Wmissing-declarations -Wnested-externs |
| # BeOS/Haiku standard library headers generate warnings |
| ifneq ($(TARGET),beos) |
| WARNFLAGS := $(WARNFLAGS) -Werror |
| endif |
| # AmigaOS needs this to avoid warnings |
| ifeq ($(TARGET),amiga) |
| CFLAGS := -U__STRICT_ANSI__ $(CFLAGS) |
| endif |
| CFLAGS := -D_BSD_SOURCE -I$(CURDIR)/include/ \ |
| -I$(CURDIR)/src -I$(CURDIR)/binding $(WARNFLAGS) $(CFLAGS) |
| # Some gcc2 versions choke on -std=c99, and it doesn't know about it anyway |
| ifneq ($(GCCVER),2) |
| CFLAGS := -std=c99 $(CFLAGS) |
| endif |
| # Parserutils & wapcaplet |
| ifneq ($(findstring clean,$(MAKECMDGOALS)),clean) |
| ifneq ($(PKGCONFIG),) |
| CFLAGS := $(CFLAGS) $(shell $(PKGCONFIG) libparserutils --cflags) |
| CFLAGS := $(CFLAGS) $(shell $(PKGCONFIG) libwapcaplet --cflags) |
| LDFLAGS := $(LDFLAGS) $(shell $(PKGCONFIG) libparserutils --libs) |
| LDFLAGS := $(LDFLAGS) $(shell $(PKGCONFIG) libwapcaplet --libs) |
| else |
| CFLAGS := $(CFLAGS) -I$(PREFIX)/include |
| LDFLAGS := $(LDFLAGS) -lparserutils -lwapcaplet |
| endif |
| endif |
| include $(NSBUILD)/Makefile.top |
| # Extra installation rules |
| Is := include/dom |
| I := /include/dom |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/dom.h;$(Is)/functypes.h |
| Is := include/dom/core |
| I := /include/dom/core |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/attr.h;$(Is)/characterdata.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/cdatasection.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/comment.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/doc_fragment.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/document.h;$(Is)/document_type.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/entity_ref.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/element.h;$(Is)/exceptions.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/implementation.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/namednodemap.h;$(Is)/node.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/nodelist.h;$(Is)/string.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/pi.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/text.h;$(Is)/typeinfo.h |
| Is := include/dom/events |
| I := /include/dom/events |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/event.h;$(Is)/ui_event.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/custom_event.h;$(Is)/mouse_event.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/keyboard_event.h;$(Is)/text_event.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/mouse_wheel_event.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/mouse_multi_wheel_event.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/mutation_event.h;$(Is)/event_target.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/mutation_name_event.h;$(Is)/events.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/event_listener.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/document_event.h |
| Is := include/dom/html |
| I := /include/dom/html |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_document.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_collection.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_html_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_head_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_link_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_title_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_body_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_meta_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_form_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_button_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_input_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_select_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_text_area_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_option_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) $(I):$(Is)/html_opt_group_element.h |
| INSTALL_ITEMS := $(INSTALL_ITEMS) /lib/pkgconfig:lib$(COMPONENT).pc.in |
| INSTALL_ITEMS := $(INSTALL_ITEMS) /lib:$(OUTPUT) |
| ifeq ($(WITH_LIBXML_BINDING),yes) |
| REQUIRED_PKGS := $(REQUIRED_PKGS) libxml-2.0 |
| endif |
| ifeq ($(WITH_HUBBUB_BINDING),yes) |
| REQUIRED_PKGS := $(REQUIRED_PKGS) libhubbub |
| endif |
| /contrib/network/netsurf/libdom/Makefile.config |
|---|
| 0,0 → 1,21 |
| # Configuration Makefile fragment |
| # Build the libxml2 binding? |
| # yes | no |
| WITH_LIBXML_BINDING := no |
| WITH_EXPAT_BINDING := yes |
| # Build the hubbub binding? |
| # yes | no |
| WITH_HUBBUB_BINDING := yes |
| # ---------------------------------------------------------------------------- |
| # BeOS-specific options |
| # ---------------------------------------------------------------------------- |
| ifeq ($(TARGET),beos) |
| # temporary |
| WITH_LIBXML_BINDING := no |
| endif |
| -include Makefile.config.override |
| /contrib/network/netsurf/libdom/README |
|---|
| 0,0 → 1,44 |
| LibDOM -- an implementation of the W3C DOM |
| ========================================== |
| Overview |
| -------- |
| LibDOM is an implementation of the W3C DOM API in C. |
| Requirements |
| ------------ |
| libdom requires the following tools: |
| + A C99 capable C compiler |
| + GNU make or compatible |
| + Perl (for the testcases) |
| LibDOM also requires the following libraries to be installed: |
| + LibParserUtils |
| + LibWapcaplet |
| Compilation |
| ----------- |
| If necessary, modify the toolchain settings in the Makefile. |
| Invoke make: |
| $ make |
| Verification |
| ------------ |
| To verify that the library is working, it is necessary to specify a |
| different makefile target than that used for normal compilation, thus: |
| $ make test |
| API documentation |
| ----------------- |
| Currently, there is none. However, the code is well commented and the |
| public API may be found in the "include" directory. The testcase sources |
| may also be of use in working out how to use it. |
| /contrib/network/netsurf/libdom/docs/RefCnt |
|---|
| 0,0 → 1,142 |
| Reference counting |
| ------------------ |
| Overview |
| -------- |
| DOM Nodes are reference counted, so as to ensure they are only destroyed |
| when nothing is using them. Each node has a reference count member |
| variable, which is a count of external references upon the node. Links |
| between nodes in the DOM tree (internal references) are not counted, as |
| they are implicitly available by consulting the relevant pointers. |
| Destruction semantics |
| --------------------- |
| A simplistic DOM tree might look like the following: |
| Node1 |
| | ^ |
| | | |
| +-------------|-+---------------+ |
| +-|-------------+-|-------------+ | |
| | | | | | | |
| v | v | v | |
| Node2<--------->Node3<--------->Node4 |
| | ^ |
| | | |
| +-----|-+-------+ |
| +-|-----+-------+ | |
| | | | | |
| v | v | |
| Node5<--------->Node6 |
| Thus, each node possesses the following links: |
| a) A link to its parent |
| b) A link to each of its children |
| c) A link to the sibling immediately prior to it |
| d) A link to the sibling immediately after it |
| None of these links are reference counted, as the reference can be |
| determined implicitly from the pointer value (i.e. a non-NULL pointer |
| implies a reference). |
| A node becomes eligible for destruction when: |
| a) its reference count variable equals 0 |
| b) its parent node pointer equals NULL |
| I.E. There exist no external references upon the node and the node has |
| been detached from the tree. |
| Note that the presence of children or siblings attached to a node has no |
| impact upon its eligibility for destruction, as these links are "weak". |
| Destruction process |
| ------------------- |
| The node destruction process proceeds as follows: |
| 1) Any children of the node are detached from it and an attempt is |
| made to destroy them. |
| 2) The node is destroyed. |
| If, when attempting to destroy children of the node, a child is found |
| to have a non-zero reference count (i.e. an external reference is |
| being held upon the child), the child (and its children) is not |
| destroyed. The child is added to the list of nodes pending deletion |
| and will be destroyed once its reference count reaches zero. |
| Example |
| ------- |
| This example uses the DOM tree depicted above, and a system state as |
| follows: |
| a) A NodeList collection references Node6. There are no other active |
| collections. The NodeList has a reference count of 1. |
| b) Node2 (and its subtree) has been removed from the document and |
| is referenced solely by the client code that caused it to be |
| removed from the document. |
| The client code unreferences Node2, thus reducing its reference count to |
| zero. It is now eligible for destruction. Destruction occurs as follows: |
| 1) Node5 is detached from Node2 and an attempt is made to destroy it. |
| a) Node5 has no children and has a reference count of zero, so it |
| is destroyed. |
| 2) Node6 is detached from Node2 and an attempt is made to destroy it. |
| a) Node6's reference count is non-zero, so it is added to the list |
| of nodes pending deletion. |
| 3) Node2 has no further children, so it is destroyed. |
| The client code unreferences the NodeList: |
| 1) The NodeList unreferences the node it's attached to (Node6). |
| Node6's reference count is now zero, so it is eligible for |
| destruction. |
| a) Node6 has no children, so it is destroyed (and removed from the |
| list of nodes pending deletion). |
| 2) The NodeList is destroyed. |
| Destruction of Documents |
| ------------------------ |
| Assumptions: |
| 1) Nodes within a document do not hold explicit references upon it. |
| 2) Container data structures which address nodes in a document hold |
| an explicit reference upon the document. |
| [FIXME: and upon the root node of the subtree they address -- this |
| implies that the explicit reference is unnecessary, as the |
| addressed node will be added to the list of nodes pending |
| deletion] |
| 3) A document has no parent (i.e. the parent pointer is always NULL). |
| 4) A given node may be located in either the document tree or the |
| list of nodes pending deletion. It may not be located in both |
| data structures simultaneously. |
| 5) Nodes in the list of nodes pending deletion are in use by the |
| client. |
| The above assumptions imply the following: |
| + If a document has a non-zero reference count, it is in use by |
| the client. (1,2) |
| + If the document's reference count reaches zero, it is no longer |
| in use and is eligible for deletion. (1,2,3) |
| + The document destructor must attempt to forcibly delete the |
| contents of the document tree as the nodes do not hold a reference |
| upon the document. (1) |
| + On destruction of a node, it must be removed from the list of nodes |
| pending deletion. (4) |
| + The document may not be destroyed if the list of nodes pending |
| deletion is non-empty after the destructor has attempted to |
| destroy the document tree. (4,5) |
| Therefore, document destruction proceeds as follows: |
| 1) Forcibly destroy the document tree. |
| 2) If the list of nodes pending deletion is non-empty, stop. |
| 3) The list of nodes pending deletion is empty, so destroy the |
| document. |
| /contrib/network/netsurf/libdom/docs/TestSuite |
|---|
| 0,0 → 1,353 |
| Assertions |
| ------------------------------------------------------------------------------- |
| fail |
| assert(false); |
| assertTrue |
| assertFalse |
| @actual is a variable name, of type boolean (or castable to boolean?) |
| or evaluate nested condition to boolean |
| assertNull |
| assertNotNull |
| @actual is a variable name |
| or evaluate nested condition |
| assertEquals |
| assertNotEquals |
| Test actual is equal (or not equal) to expected. |
| <assertEquals actual="result" expected="expectedResult" ignoreCase="true/false/auto" context="attribute/element" bitmask="..."/> |
| For Collections (or Lists), need to check neither list is null, then that both lists have the same size, then that all their elements are equal. |
| @ignoreCase="auto" |
| if contentType == "text/html": |
| if context == "attribute", do case insensitive test |
| if context == "element", do case sensitive test against expected.toUpperCase() |
| @context used in combination with ignoreCase="auto" |
| @bitmask used in DOM Level 3 only. Tests: (actual & bitmask) equals (expectedResult & bitmask) where bitmask is an int |
| Alternatively, can include nested statement (presumably as a substitute to @actual), but can't see this is used anywhere. |
| assertSame |
| Tests two objects for identity. |
| If not, call assertEquals() |
| Don't really understand the point of this assert |
| (note about assertNull, assertNotNull, assertEquals, assertNotEquals, assertSame) |
| Alternatively, can include nested statement (presumably as a substitute to @actual), but can't see this is used anywhere. |
| assertInstanceOf |
| Used in [hc_]namednodemapreturnattrnode.xml |
| Can use Node.getNodeType() to get runtime type |
| assertSize |
| Tests a Java Collection has the specified size. |
| <assertSize size="2" collection="notifications"/> |
| assertEventCount |
| (not used) |
| assertURIEquals |
| Compare pieces of the URI in @actual |
| @actual |
| @scheme |
| @path |
| @host |
| @file |
| @name |
| @query |
| @fragment |
| @isAbsolute boolean |
| assertImplementationException |
| DOM Level 2 Events dispatchEvent01.xml |
| assertDOMException |
| Tests that a DOMException is thrown with a specified code. Try/catching not nested. |
| <assertDOMException id="setValue_throws_NO_MODIFICATION_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild obj="attrNode" oldChild="textNode" var="removedNode"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| boolean success = false; |
| try { |
| removedNode = attrNode.removeChild(textNode); |
| } catch (DOMException ex) { |
| success = (ex.code == DOMException.NO_MODIFICATION_ALLOWED_ERR); |
| } |
| assertTrue(success); |
| assertLowerSeverity |
| DOM Level 3 Core only |
| Conditions |
| ------------------------------------------------------------------------------- |
| same |
| (not used) |
| equals |
| notEquals |
| less |
| lessOrEquals |
| (not used) |
| greater |
| greaterOrEquals |
| (not used) |
| isNull |
| (not used) |
| notNull |
| and |
| or |
| xor |
| (not used) |
| not |
| instanceOf |
| (not used) |
| isTrue |
| isFalse |
| hasSize |
| (not used) |
| contentType |
| contains |
| DOM Level 3 Core and LS only |
| hasFeature |
| calls DOMImplementation.hasFeature() |
| @feature quoted string e.g. "XML" |
| @version quoted string e.g. "1.0" |
| @value boolean |
| @var variable to assign the result to |
| @obj name of var holding the DOMImplementation |
| implementationAttribute |
| pass param to the test suite's DOMTestDocumentBuilderFactory (e.g. validating) |
| Statements |
| ------------------------------------------------------------------------------- |
| var |
| Can contain nested <member> elements when the var has @type Collection |
| Can contain <handleError> element when the var type @type DOMErrorHandler. |
| This then creates an class implementing DOMErrorHandler, overriding the handleError() method. |
| This is only used in DOM Level 3 Core. |
| @name variable name |
| @type type of variable |
| @value initially assigned value |
| @isNull boolean assign initial value of NULL (essentially mutually exclusive with @value ?) |
| assign |
| <assign var="..." value="..."/> |
| increment |
| decrement |
| <increment var="..." value="..."/> |
| append |
| <append collection="..." item="..."/> |
| Append an object to the end of a Collection. |
| In Java, this is implemented with an ArrayList. |
| plus |
| subtract |
| mult |
| divide |
| load |
| if |
| while |
| try |
| Fail if reach the end of the try without throwing an exception specified in <catch> |
| <try> |
| ... |
| <catch> |
| <DOMException code="..."/> |
| <DOMException code="..."/> |
| ... |
| </catch> |
| </try> |
| No nesting in test cases, but sometimes more than one instance in a single test. |
| for-each |
| <for-each collection="..." member="..."> |
| comment |
| Only used in DOM Level 3 XPath. |
| return |
| Only used in DOM Level 2/3. Returns immediately from method call with optional @value |
| userObj |
| (not used) |
| atEvents |
| capturedEvents |
| bubbledEvents |
| allEvents |
| DOM Level 2 Events only |
| createXPathEvaluator |
| DOM Level 3 XPath only |
| getResourceURI |
| DOM Level 3 LS only |
| substring |
| <substringData var="..." obj="..." offset="..." count="..."/> |
| Calls @obj.substringData() where obj is an instance of CharacterData |
| createTempURI |
| DOMImplementationRegistry.newInstance |
| allErrors |
| Only used in DOM Level 3 |
| Calls org.w3c.domts.DOMErrorMonitor.getAllErrors(), which is an instance of DOMErrorHandler |
| allNotifications |
| operation |
| key |
| dst |
| DOM Level 3 Core only |
| Datatypes |
| ------------------------------------------------------------------------------- |
| int |
| short |
| double |
| boolean |
| Primitives |
| DOMString |
| List |
| In Java, an ArrayList instance typed as a List |
| Collection |
| In Java, an ArrayList instance typed as a Collection |
| <var name="expectedResult" type="Collection"> |
| <member>"ent1"</member> |
| <member>"ent2"</member> |
| EventMonitor |
| DOM Level 2 Events only |
| DOMErrorMonitor |
| DOM Level 3 only |
| UserDataMonitor |
| UserDataNotification |
| LSInputStream |
| DOM Level 3 Core only |
| Attr |
| CDATASection |
| CharacterData |
| Comment |
| Document |
| DocumentFragment |
| DocumentType |
| DOMImplementation |
| Element |
| Entity |
| EntityReference |
| NamedNodeMap |
| Node |
| NodeList |
| Notation |
| ProcessingInstruction |
| Text |
| DOM types |
| ------------------------------------------------------------------------------- |
| WHAT ABOUT RETURN VALUES? |
| for method calls and attribute getters (&result) |
| ASSERTIONS (other statements?) |
| [temp variables for assert params] |
| assertFoo(...) |
| for @expected, produce a var decl/ref |
| required-type is the type of @actual |
| CONDITIONS IN CONTROL STRUCTURES |
| [temp variables for condition params] |
| if (<condition>) |
| for every condition clause that requires it (e.g. <equals>), produce a var decl/ref |
| required-type is the type of @actual |
| e.g. |
| <var name="myVar" type="DOMString"/> |
| <equals actual="myVar" expected=""beans""/> |
| required-type is DOMString |
| METHOD CALL |
| [temp variables for method params] |
| [temp variable to hold method result] |
| getElementsByTagName(doc, param_a, param_b, param_c, &result) |
| [assign temp variable to real result var] |
| produce var decl/ref for each param: a, b, c |
| required-type is the method param's type in the domspec |
| ATTRIBUTE SET |
| [temp variables for setting attribute] |
| setFoo(node, param) |
| required-type is the attribute's type in the domspec |
| ATTRIBUTE GET |
| [temp variable to hold getter result] |
| getFoo(node, &result) |
| [assign temp variable to real result var] |
| call produce-var-reference in getFoo() call to generate &result |
| call produce-var-assignment after getFoo() to convert the temp result into the desired result |
| PSEUDO TEMPLATES |
| template name="produce-var-declaration" |
| param name="var-or-literal" |
| param name="required-type" |
| if (needs temp variable) |
| declare and assign new temporary variable $var_x$ |
| /if |
| template name="produce-var-reference" |
| choose |
| when (needs temp variable) |
| print temporary variable $var_x$ using generate-id() |
| when (needs cast) |
| call-template name="cast" |
| otherwise |
| $var-or-literal |
| /choose |
| template name="produce-var-assignment" |
| if (needs temp variable) |
| $var-or-literal = conversion_function($var_x$); |
| /if |
| /contrib/network/netsurf/libdom/docs/Todo |
|---|
| 0,0 → 1,7 |
| TODO list |
| ========= |
| + Fill out stub functions for DOM3 core |
| + Rest of DOM level 3 |
| + DOM level 2 |
| + DOM level 1 |
| /contrib/network/netsurf/libdom/examples/dom-structure-dump.c |
|---|
| 0,0 → 1,359 |
| /* |
| * This file is part of LibDOM. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * |
| * Copyright 2010 - 2011 Michael Drake <tlsa@netsurf-browser.org> |
| */ |
| /* |
| * Load an HTML file into LibDOM with Hubbub and print out the DOM structure. |
| * |
| * This example demonstrates the following: |
| * |
| * 1. Using LibDOM's Hubbub binding to read an HTML file into LibDOM. |
| * 2. Walking around the DOM tree. |
| * 3. Accessing DOM node attributes. |
| * |
| * Example input: |
| * <html><body><h1 class="woo">NetSurf</h1> |
| * <p>NetSurf is <em>awesome</em>!</p> |
| * <div><h2>Hubbub</h2><p>Hubbub is too.</p> |
| * <p>Big time.</p></div></body></html> |
| * |
| * Example output: |
| * |
| * HTML |
| * +-BODY |
| * | +-H1 class="woo" |
| * | +-P |
| * | | +-EM |
| * | +-DIV |
| * | | +-H2 |
| * | | +-P |
| * | | +-P |
| * |
| */ |
| #include <assert.h> |
| #include <stdarg.h> |
| #include <stdbool.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <dom/dom.h> |
| #include <dom/bindings/hubbub/parser.h> |
| /** |
| * Generate a LibDOM document DOM from an HTML file |
| * |
| * \param file The file path |
| * \return pointer to DOM document, or NULL on error |
| */ |
| dom_document *create_doc_dom_from_file(char *file) |
| { |
| size_t buffer_size = 1024; |
| dom_hubbub_parser *parser = NULL; |
| FILE *handle; |
| int chunk_length; |
| dom_hubbub_error error; |
| dom_hubbub_parser_params params; |
| dom_document *doc; |
| unsigned char buffer[buffer_size]; |
| params.enc = NULL; |
| params.fix_enc = true; |
| params.enable_script = false; |
| params.msg = NULL; |
| params.script = NULL; |
| params.ctx = NULL; |
| params.daf = NULL; |
| /* Create Hubbub parser */ |
| error = dom_hubbub_parser_create(¶ms, &parser, &doc); |
| if (error != DOM_HUBBUB_OK) { |
| printf("Can't create Hubbub Parser\n"); |
| return NULL; |
| } |
| /* Open input file */ |
| handle = fopen(file, "rb"); |
| if (handle == NULL) { |
| dom_hubbub_parser_destroy(parser); |
| printf("Can't open test input file: %s\n", file); |
| return NULL; |
| } |
| /* Parse input file in chunks */ |
| chunk_length = buffer_size; |
| while (chunk_length == buffer_size) { |
| chunk_length = fread(buffer, 1, buffer_size, handle); |
| error = dom_hubbub_parser_parse_chunk(parser, buffer, |
| chunk_length); |
| if (error != DOM_HUBBUB_OK) { |
| dom_hubbub_parser_destroy(parser); |
| printf("Parsing errors occur\n"); |
| return NULL; |
| } |
| } |
| /* Done parsing file */ |
| error = dom_hubbub_parser_completed(parser); |
| if (error != DOM_HUBBUB_OK) { |
| dom_hubbub_parser_destroy(parser); |
| printf("Parsing error when construct DOM\n"); |
| return NULL; |
| } |
| /* Finished with parser */ |
| dom_hubbub_parser_destroy(parser); |
| /* Close input file */ |
| if (fclose(handle) != 0) { |
| printf("Can't close test input file: %s\n", file); |
| return NULL; |
| } |
| return doc; |
| } |
| /** |
| * Dump attribute/value for an element node |
| * |
| * \param node The element node to dump attribute details for |
| * \param attribute The attribute to dump |
| * \return true on success, or false on error |
| */ |
| bool dump_dom_element_attribute(dom_node *node, char *attribute) |
| { |
| dom_exception exc; |
| dom_string *attr = NULL; |
| dom_string *attr_value = NULL; |
| dom_node_type type; |
| const char *string; |
| size_t length; |
| /* Should only have element nodes here */ |
| exc = dom_node_get_node_type(node, &type); |
| if (exc != DOM_NO_ERR) { |
| printf(" Exception raised for node_get_node_type\n"); |
| return false; |
| } |
| assert(type == DOM_ELEMENT_NODE); |
| /* Create a dom_string containing required attribute name. */ |
| exc = dom_string_create_interned((uint8_t *)attribute, |
| strlen(attribute), &attr); |
| if (exc != DOM_NO_ERR) { |
| printf(" Exception raised for dom_string_create\n"); |
| return false; |
| } |
| /* Get class attribute's value */ |
| exc = dom_element_get_attribute(node, attr, &attr_value); |
| if (exc != DOM_NO_ERR) { |
| printf(" Exception raised for element_get_attribute\n"); |
| dom_string_unref(attr); |
| return false; |
| } else if (attr_value == NULL) { |
| /* Element lacks required attribute */ |
| dom_string_unref(attr); |
| return true; |
| } |
| /* Finished with the attr dom_string */ |
| dom_string_unref(attr); |
| /* Get attribute value's string data */ |
| string = dom_string_data(attr_value); |
| length = dom_string_byte_length(attr_value); |
| /* Print attribute info */ |
| printf(" %s=\"%.*s\"", attribute, (int)length, string); |
| /* Finished with the attr_value dom_string */ |
| dom_string_unref(attr_value); |
| return true; |
| } |
| /** |
| * Print a line in a DOM structure dump for an element |
| * |
| * \param node The node to dump |
| * \param depth The node's depth |
| * \return true on success, or false on error |
| */ |
| bool dump_dom_element(dom_node *node, int depth) |
| { |
| dom_exception exc; |
| dom_string *node_name = NULL; |
| dom_node_type type; |
| int i; |
| const char *string; |
| size_t length; |
| /* Only interested in element nodes */ |
| exc = dom_node_get_node_type(node, &type); |
| if (exc != DOM_NO_ERR) { |
| printf("Exception raised for node_get_node_type\n"); |
| return false; |
| } else if (type != DOM_ELEMENT_NODE) { |
| /* Nothing to print */ |
| return true; |
| } |
| /* Get element name */ |
| exc = dom_node_get_node_name(node, &node_name); |
| if (exc != DOM_NO_ERR) { |
| printf("Exception raised for get_node_name\n"); |
| return false; |
| } else if (node_name == NULL) { |
| printf("Broken: root_name == NULL\n"); |
| return false; |
| } |
| /* Print ASCII tree structure for current node */ |
| if (depth > 0) { |
| for (i = 0; i < depth; i++) { |
| printf("| "); |
| } |
| printf("+-"); |
| } |
| /* Get string data and print element name */ |
| string = dom_string_data(node_name); |
| length = dom_string_byte_length(node_name); |
| printf("[%.*s]", (int)length, string); |
| if (length == 5 && strncmp(string, "title", 5) == 0) { |
| /* Title tag, gather the title */ |
| dom_string *str; |
| exc = dom_node_get_text_content(node, &str); |
| if (exc == DOM_NO_ERR && str != NULL) { |
| printf(" $%.*s$", (int)dom_string_byte_length(str), |
| dom_string_data(str)); |
| dom_string_unref(str); |
| } |
| } |
| /* Finished with the node_name dom_string */ |
| dom_string_unref(node_name); |
| /* Print the element's id & class, if it has them */ |
| if (dump_dom_element_attribute(node, "id") == false || |
| dump_dom_element_attribute(node, "class") == false) { |
| /* Error occured */ |
| printf("\n"); |
| return false; |
| } |
| printf("\n"); |
| return true; |
| } |
| /** |
| * Walk though a DOM (sub)tree, in depth first order, printing DOM structure. |
| * |
| * \param node The root node to start from |
| * \param depth The depth of 'node' in the (sub)tree |
| */ |
| bool dump_dom_structure(dom_node *node, int depth) |
| { |
| dom_exception exc; |
| dom_node *child; |
| /* Print this node's entry */ |
| if (dump_dom_element(node, depth) == false) { |
| /* There was an error; return */ |
| return false; |
| } |
| /* Get the node's first child */ |
| exc = dom_node_get_first_child(node, &child); |
| if (exc != DOM_NO_ERR) { |
| printf("Exception raised for node_get_first_child\n"); |
| return false; |
| } else if (child != NULL) { |
| /* node has children; decend to children's depth */ |
| depth++; |
| /* Loop though all node's children */ |
| do { |
| dom_node *next_child; |
| /* Visit node's descendents */ |
| if (dump_dom_structure(child, depth) == false) { |
| /* There was an error; return */ |
| dom_node_unref(child); |
| return false; |
| } |
| /* Go to next sibling */ |
| exc = dom_node_get_next_sibling(child, &next_child); |
| if (exc != DOM_NO_ERR) { |
| printf("Exception raised for " |
| "node_get_next_sibling\n"); |
| dom_node_unref(child); |
| return false; |
| } |
| dom_node_unref(child); |
| child = next_child; |
| } while (child != NULL); /* No more children */ |
| } |
| return true; |
| } |
| /** |
| * Main entry point from OS. |
| */ |
| int main(int argc, char **argv) |
| { |
| dom_exception exc; /* returned by libdom functions */ |
| dom_document *doc = NULL; /* document, loaded into libdom */ |
| dom_node *root = NULL; /* root element of document */ |
| /* Load up the input HTML file */ |
| doc = create_doc_dom_from_file((argc > 1) ? (argv[1]) : "files/test.html"); |
| if (doc == NULL) { |
| printf("Failed to load document.\n"); |
| return EXIT_FAILURE; |
| } |
| /* Get root element */ |
| exc = dom_document_get_document_element(doc, &root); |
| if (exc != DOM_NO_ERR) { |
| printf("Exception raised for get_document_element\n"); |
| dom_node_unref(doc); |
| return EXIT_FAILURE; |
| } else if (root == NULL) { |
| printf("Broken: root == NULL\n"); |
| dom_node_unref(doc); |
| return EXIT_FAILURE; |
| } |
| /* Dump DOM structure */ |
| if (dump_dom_structure(root, 0) == false) { |
| printf("Failed to complete DOM structure dump.\n"); |
| dom_node_unref(root); |
| dom_node_unref(doc); |
| return EXIT_FAILURE; |
| } |
| dom_node_unref(root); |
| /* Finished with the dom_document */ |
| dom_node_unref(doc); |
| return EXIT_SUCCESS; |
| } |
| /contrib/network/netsurf/libdom/examples/files/test.html |
|---|
| 0,0 → 1,213 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" |
| "http://www.w3.org/TR/html4/strict.dtd"> |
| <html> |
| <head> |
| <title>NetSurf Web Browser</title> |
| <link rel="stylesheet" title="Standard" type="text/css" href="netsurf.css"> |
| <link rel="icon" type="image/png" href="/webimages/favicon.png"> |
| </head> |
| <body> |
| <h1 class="banner"><a href="/"><img src="netsurf.png" alt="NetSurf"></a></h1> |
| <div class="navigation"> |
| <div class="navsection"> |
| <ul> |
| <li><a href="/about/">About NetSurf</a></li> |
| <li><a href="/downloads/">Downloads</a></li> |
| <li><a href="/documentation/">Documentation</a></li> |
| <li><a href="/developers/">Development area</a></li> |
| <li><a href="/webmasters/">Webmaster area</a></li> |
| <li><a href="/contact/">Contact</a></li> |
| </ul> |
| </div> |
| <div class="navsection"> |
| <ul class="languages"> |
| <!--<li><a href="index.de">Deutsch</a></li>--> |
| <li>English</li> |
| <!--<li><a href="index.fr">Français</a></li>--> |
| <!--<li><a href="index.nl">Nederlands</a></li>--> |
| </ul> |
| </div> |
| <div class="navsection"> |
| <ul class="sitelinks"> |
| <li><a href="http://wiki.netsurf-browser.org/">Development wiki</a></li> |
| <li><a href="http://source.netsurf-browser.org/">SVN repository viewer</a></li> |
| </ul> |
| </div> |
| <div class="navsection"> |
| <h2 class="navtitle">Project Overview</h2> |
| <p>NetSurf project at-a-glance.</p> |
| <dl> |
| <dt>Core project:</dt> |
| <dd> |
| <dl> |
| <dt><a href="#leader">NetSurf web browser</a></dt> |
| </dl> |
| </dd> |
| <dt>Sub-projects:</dt> |
| <dd> |
| <dl> |
| <dt><a href="/projects/hubbub/">Hubbub</a></dt> |
| <dd>HTML5 compliant parsing library</dd> |
| <dt><a href="/projects/libcss/">LibCSS</a><dt> |
| <dd>CSS parser and selection library<dd> |
| <dt><a href="/projects/libdom/">LibDOM</a></dt> |
| <dd>DOM library</dd> |
| <dt><a href="/projects/libparserutils/">LibParserUtils</a><dt> |
| <dd>Parser building library<dd> |
| <dt><a href="/projects/libwapcaplet/">LibWapcaplet</a><dt> |
| <dd>String internment library<dd> |
| <dt><a href="/projects/libsvgtiny/">Libsvgtiny</a></dt> |
| <dd>SVG Tiny library</dd> |
| <dt><a href="/projects/libnsfb/">LibNSFB</a><dt> |
| <dd>Framebuffer Abstraction library<dd> |
| <dt><a href="/projects/libnsbmp/">Libnsbmp</a></dt> |
| <dd>BMP and ICO decoding library<dd> |
| <dt><a href="/projects/libnsgif/">Libnsgif</a></dt> |
| <dd>GIF decoding library<dd> |
| <dt><a href="/projects/librosprite/">LibROSprite</a></dt> |
| <dd>RISC OS Sprite decoding library<dd> |
| <dt><a href="/projects/iconv/">Iconv</a></dt> |
| <dd>RISC OS character encoding support module</dd> |
| <dt><a href="/projects/rufl/">RUfl</a></dt> |
| <dd>RISC OS Unicode font library</dd> |
| <dt><a href="/projects/tinct/">Tinct</a></dt> |
| <dd>Advanced RISC OS Sprite plotting module</dd> |
| <dt><a href="/projects/libpencil/">Libpencil</a></dt> |
| <dd>RISC OS Drawfile export library</dd> |
| </dl> |
| </dd> |
| </dl> |
| </div> |
| </div> |
| <div class="content"> |
| <div class="frontpageintro"> |
| <p id="leader">Small as a mouse, fast as a cheetah and available for free. NetSurf is a multi-platform web browser for <a href="http://www.riscosopen.org/">RISC OS</a>, UNIX-like platforms (including Linux) and more.</p> |
| <p>Whether you want to check your webmail, read the news or post to discussion forums, NetSurf is your lightweight gateway to the world wide web. Actively developed, NetSurf is continually evolving and improving.</p> |
| <div class="frontscreen"><p class="frontscreen"><a href="/about/screenshots/"><img src="about/screenshots/thumbnails/rowikipedia.png" alt="NetSurf screenshot"> <span class="seemore">See more screenshots</span></a></p></div> |
| <p>Written in C, this award winning open source project features its own layout engine. It is licensed under GPL version 2.</p> |
| <h2 id="whynetsurf">Why choose NetSurf?</h2> |
| <dl class="motivation"> |
| <dt>Speed</dt> |
| <dd>Efficiency lies at the heart of the NetSurf engine, allowing it to outwit the heavyweights of the web browser world. The NetSurf team continue to squeeze more speed out of their code.</dd> |
| <dt>Interface innovation</dt> |
| <dd>Simple to use and easy to grasp, NetSurf significantly raised the bar for user interface design on the RISC OS platform. Designed carefully by RISC OS users and developers to integrate well with the desktop, NetSurf is seen as the benchmark for future applications. NetSurf pioneered the concept of web page thumbnailing, offering an intuitive graphical tree-like view of visited web sites.</dd> |
| <dt>Lean requirements</dt> |
| <dd>From a modern monster PC to a humble 30MHz ARM 6 computer with 16MB of RAM, the web browser will keep you surfing the web whatever your system. Originally written for computer hardware normally found in PDAs, cable TV boxes, mobile phones and other hand-held gadgets, NetSurf is compact and low maintenance by design.</dd> |
| <dt>Portable</dt> |
| <dd>NetSurf can be built for a number of modern computer platforms 'out of the box'. Written in C, with portability in mind, NetSurf is developed by programmers from a wide range of computing backgrounds, ensuring it remains available for as many users as possible.</dd> |
| <dt>Standards compliant</dt> |
| <dd>Despite a myriad of standards to support, NetSurf makes surfing the web enjoyable and stress-free by striving for complete standards compliancy. As an actively developed project, NetSurf aims to stay abreast of new and upcoming web technologies.</dd> |
| </dl> |
| <p>See the <a href="/about/#ProjectGoals">project goals</a> and <a href="/documentation/progress">progress</a> page for further information on where NetSurf is headed.</p> |
| <h2 id="WantToHelp">Want to help?</h2> |
| <p>There are always things that need doing, and not enough time in the day, so we'd be delighted if you want to help develop NetSurf. Visit the "<a href="/developers/contribute">How can I help?</a>" page to see ideas for contributing to the project.</p> |
| <p>If you can program and you'd like to improve NetSurf, then we'd love to hear from you. Pick an area you'd like to improve or a feature you want to add and <a href="/contact/">contact the developers</a>. Also, take a look at the <a href="/developers/">developer and contributor</a> area of this site.</p> |
| </div> |
| <div class="frontpagelatestinfo"> |
| <div> |
| <div class="downloadbox"> |
| <div class="downloadcontainer"> |
| <div class="downloadcontent"> |
| <h2 id="downloadrelease"><a href="/downloads/">Download NetSurf 2.6</a></h2> |
| <ul> |
| <li><a href="/downloads/riscos/">For RISC OS</a></li> |
| <li><a href="/downloads/gtk/">For Linux</a></li> |
| <li><a href="/downloads/">Other systems</a></li> |
| <li><a href="/downloads/source/">Source code</a></li> |
| </ul> |
| </div> |
| <div class="topleft"></div> |
| <div class="topright"></div> |
| <div class="bottomleft"></div> |
| <div class="bottomright"></div> |
| </div> |
| <div class="arrow"></div> |
| </div> |
| <h2 id="news">Latest news</h2> |
| <dl class="frontnews"> |
| <dt><a href="/downloads/">NetSurf 2.6 released</a> <span>21 Sep 2010</span></dt> |
| <dd>NetSurf 2.6 is primarily a bug fix release. It contains some improvements to page rendering, fetching & caching, memory usage, as well as some front-end specific fixes. Full details in the change log. We recommend all users upgrade.</dd> |
| <dt><a href="/downloads/">NetSurf 2.5 released</a> <span>24 Apr 2010</span></dt> |
| <dd>NetSurf 2.5 contains many improvements over the previous release. The major changes are the use of our brand new CSS parser and selection engine (LibCSS), and a newly designed cache for fetched content. Full details in the change log. We recommend all users upgrade.</dd> |
| <dt><a href="http://vlists.pepperfish.net/pipermail/netsurf-users-netsurf-browser.org/2010-January/009241.html">NetSurf at Wakefield Show 2010</a> <span>14 Jan 2010</span></dt> |
| <dd>NetSurf 2.5 is expected to be released at the Wakefield RISC OS Show. The release will focus on the CSS engine, memory usage and speed, as well as fixing bugs. NetSurf 2.5 is likely to be the last release for RISC OS.</dd> |
| </dl> |
| <p class="more"><a href="/about/news" class="seemore">See more news</a></p> |
| <h2 id="features">NetSurf 2.6 features</h2> |
| <p>NetSurf 2.6 is available for: RISC OS; Linux and other UNIX-like systems; and AmigaOS 4.</p> |
| <dl> |
| <dt>General</dt> |
| <dd> |
| <ul> |
| <li>Web standards: HTML 4.01 and CSS 2.1</li> |
| <li>Image formats: PNG, GIF, JPEG, SVG, JNG, MNG and BMP</li> |
| <li>HTTPS for secure online transactions</li> |
| <li>Unicode text</li> |
| <li>Web page thumbnailing</li> |
| <li>Local history trees</li> |
| <li>Global history</li> |
| <li>URL completion</li> |
| <li>Text selection</li> |
| <li>Scale view</li> |
| <li>Search-as-you-type text search highlighting</li> |
| <li>Save pages complete with images</li> |
| </ul> |
| </dd> |
| <dt>RISC OS only</dt> |
| <dd> |
| <ul> |
| <li>Image formats: Sprite, Drawfile and ArtWorks</li> |
| <li>Hotlist management (bookmarks)</li> |
| <li>Cookie viewer</li> |
| <li>Drawfile export</li> |
| </ul> |
| </dd> |
| </dl> |
| <h2 id="Awards">Awards</h2> |
| <p class="award"><a class="award" href="http://www.iconbar.com/articles/The_Icon_Bar_Awards_2009/index1244.html"><img src="/webimages/tiba2009.png" alt=""></a>NetSurf picked up another accolade, winning in the "best non-commercial product" category at <a href="http://www.iconbar.com/articles/The_Icon_Bar_Awards_2009/index1244.html">The Icon Bar Awards 2009</a>. NetSurf had previously been <a href="http://www.iconbar.com/articles/Nominations_open_for_the_sDrobes_Icon_Bar_awards_2009/index1240.html">nominated</a> by <a href="http://www.iconbar.com/">The Icon Bar</a>'s readers.</p> |
| <p class="award"><a class="award" href="http://www.drobe.co.uk/article.php?id=2389"><img src="/webimages/da2008.png" alt=""></a>At <a href="http://www.drobe.co.uk/">Drobe Launch Pad</a>'s annual awards, NetSurf triumphed again in the category for "best non-commercial software", winning the <a href="http://www.drobe.co.uk/article.php?id=2389">2008 award</a>.</p> |
| <p class="more"><a href="/about/awards" class="seemore">See more awards</a></p> |
| </div> |
| </div> |
| <div class="footer"> |
| <p>Copyright 2003 - 2010 The NetSurf Developers</p> |
| </div> |
| </div> |
| <form method="get" action="http://www.google.co.uk/search"> |
| <div class="searchbox"> |
| <input type="hidden" name="q" value="site:netsurf-browser.org"> |
| <input type="text" name="q" maxlength="255"><br> |
| <input type="submit" value="Search" name="btnG"> |
| </div> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/examples/makefile |
|---|
| 0,0 → 1,18 |
| CC := gcc |
| LD := gcc |
| CFLAGS := `pkg-config --cflags libdom` `pkg-config --cflags libwapcaplet` -Wall -O0 -g |
| LDFLAGS := `pkg-config --libs libdom` `pkg-config --libs libwapcaplet` |
| SRC := dom-structure-dump.c |
| dom-structure-dump: $(SRC:.c=.o) |
| @$(LD) -o $@ $^ $(LDFLAGS) |
| .PHONY: clean |
| clean: |
| $(RM) dom-structure-dump $(SRC:.c=.o) |
| %.o: %.c |
| @$(CC) -c $(CFLAGS) -o $@ $< |
| /contrib/network/netsurf/libdom/gdb/libdom.py |
|---|
| 0,0 → 1,157 |
| # LibDOM related commands and utilities for gdb |
| import gdb |
| def dom_get_type_ptr(typename): |
| return gdb.lookup_type(typename).pointer() |
| def dom_node_at(ptr): |
| nodetype = dom_get_type_ptr("dom_node_internal") |
| return ptr.cast(nodetype).dereference() |
| def dom_document_at(ptr): |
| doctype = dom_get_type_ptr("dom_document") |
| return ptr.cast(doctype).dereference() |
| def dom_node_type(node): |
| return node["type"] |
| def dom_node_refcnt(node): |
| return node["base"]["refcnt"] |
| def lwc_string_value(strptr): |
| cptr = strptr+1 |
| charptr = cptr.cast(dom_get_type_ptr("char")) |
| return charptr.string() |
| def dom_string__is_intern(intstr): |
| return str(intstr['type']) == "DOM_STRING_INTERNED" |
| def cdata_string_value(cdata): |
| cptr = cdata['ptr'] |
| charptr = cptr.cast(dom_get_type_ptr("char")) |
| return charptr.string() |
| def dom_string_value(stringptr): |
| intstr = stringptr.cast(dom_get_type_ptr("dom_string_internal")).dereference() |
| if intstr.address == gdb.parse_and_eval("(dom_string_internal*)0"): |
| return "" |
| if dom_string__is_intern(intstr): |
| return lwc_string_value(intstr['data']['intern']) |
| else: |
| return cdata_string_value(intstr['data']['cdata']) |
| def dom_node_name(node): |
| namestr = node["name"] |
| return " '%s'" % dom_string_value(namestr) |
| def dom_node_pending_offset(): |
| return gdb.parse_and_eval("(int)&((struct dom_node_internal *)0)->pending_list") |
| def dom_print_node(node, prefix = ""): |
| print("%s%s @ %s [%s]%s" % (prefix, dom_node_type(node), |
| node.address, dom_node_refcnt(node), |
| dom_node_name(node))) |
| def dom_walk_tree(node, prefix = ""): |
| dom_print_node(node, prefix) |
| current = node['first_child'].dereference() |
| while current.address != 0: |
| dom_walk_tree(current, "%s " % prefix) |
| current = current['next'].dereference() |
| def dom_document_show(doc): |
| print "Node Tree:" |
| node = dom_node_at(doc.address) |
| dom_walk_tree(node, " ") |
| pending = doc['pending_nodes'] |
| if pending['next'] != pending.address: |
| print "Pending Node trees:" |
| current_list_entry = pending['next'] |
| while current_list_entry is not None: |
| voidp = current_list_entry.cast(dom_get_type_ptr("void")) |
| voidp = voidp - dom_node_pending_offset() |
| node = dom_node_at(voidp) |
| dom_walk_tree(node, " ") |
| current_list_entry = node['pending_list']['next'] |
| if current_list_entry == pending.address: |
| current_list_entry = None |
| class DOMCommand(gdb.Command): |
| """DOM related commands""" |
| def __init__(self): |
| gdb.Command.__init__(self, "dom", gdb.COMMAND_DATA, |
| gdb.COMPLETE_COMMAND, True) |
| class DOMNodeCommand(gdb.Command): |
| """DOMNode related commands""" |
| def __init__(self): |
| gdb.Command.__init__(self, "dom node", gdb.COMMAND_DATA, |
| gdb.COMPLETE_COMMAND, True) |
| class DOMDocumentCommand(gdb.Command): |
| """DOMDocument related commands""" |
| def __init__(self): |
| gdb.Command.__init__(self, "dom document", gdb.COMMAND_DATA, |
| gdb.COMPLETE_COMMAND, True) |
| class DOMNodeShowCommand(gdb.Command): |
| """Show a node at a given address.""" |
| def __init__(self): |
| gdb.Command.__init__(self, "dom node show", gdb.COMMAND_DATA, |
| gdb.COMPLETE_NONE, True) |
| def invoke(self, arg, from_tty): |
| args = gdb.string_to_argv(arg) |
| self._invoke(*args) |
| def _invoke(self, nodeptr): |
| _ptr = gdb.parse_and_eval(nodeptr) |
| node = dom_node_at(_ptr) |
| dom_print_node(node) |
| class DOMNodeWalkCommand(gdb.Command): |
| """Walk a node tree at a given address.""" |
| def __init__(self): |
| gdb.Command.__init__(self, "dom node walk", gdb.COMMAND_DATA, |
| gdb.COMPLETE_NONE, True) |
| def invoke(self, arg, from_tty): |
| args = gdb.string_to_argv(arg) |
| self._invoke(*args) |
| def _invoke(self, nodeptr): |
| _ptr = gdb.parse_and_eval(nodeptr) |
| node = dom_node_at(_ptr) |
| dom_walk_tree(node) |
| class DOMDocumentShowCommand(gdb.Command): |
| """Show a document at a given address.""" |
| def __init__(self): |
| gdb.Command.__init__(self, "dom document show", gdb.COMMAND_DATA, |
| gdb.COMPLETE_NONE, True) |
| def invoke(self, arg, from_tty): |
| args = gdb.string_to_argv(arg) |
| self._invoke(*args) |
| def _invoke(self, docptr): |
| _ptr = gdb.parse_and_eval(docptr) |
| doc = dom_document_at(_ptr) |
| dom_document_show(doc) |
| DOMCommand() |
| DOMNodeCommand() |
| DOMNodeShowCommand() |
| DOMNodeWalkCommand() |
| DOMDocumentCommand() |
| DOMDocumentShowCommand() |
| /contrib/network/netsurf/libdom/include/dom/core/attr.h |
|---|
| 0,0 → 1,147 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_attr_h_ |
| #define dom_core_attr_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/node.h> |
| struct dom_element; |
| struct dom_type_info; |
| struct dom_node; |
| struct dom_attr; |
| typedef struct dom_attr dom_attr; |
| /** |
| * The attribute type |
| */ |
| typedef enum { |
| DOM_ATTR_UNSET = 0, |
| DOM_ATTR_STRING, |
| DOM_ATTR_BOOL, |
| DOM_ATTR_SHORT, |
| DOM_ATTR_INTEGER |
| } dom_attr_type; |
| /* DOM Attr vtable */ |
| typedef struct dom_attr_vtable { |
| struct dom_node_vtable base; |
| dom_exception (*dom_attr_get_name)(struct dom_attr *attr, |
| dom_string **result); |
| dom_exception (*dom_attr_get_specified)(struct dom_attr *attr, |
| bool *result); |
| dom_exception (*dom_attr_get_value)(struct dom_attr *attr, |
| dom_string **result); |
| dom_exception (*dom_attr_set_value)(struct dom_attr *attr, |
| dom_string *value); |
| dom_exception (*dom_attr_get_owner_element)(struct dom_attr *attr, |
| struct dom_element **result); |
| dom_exception (*dom_attr_get_schema_type_info)(struct dom_attr *attr, |
| struct dom_type_info **result); |
| dom_exception (*dom_attr_is_id)(struct dom_attr *attr, bool *result); |
| } dom_attr_vtable; |
| static inline dom_exception dom_attr_get_name(struct dom_attr *attr, |
| dom_string **result) |
| { |
| return ((dom_attr_vtable *) ((dom_node *) attr)->vtable)-> |
| dom_attr_get_name(attr, result); |
| } |
| #define dom_attr_get_name(a, r) dom_attr_get_name((struct dom_attr *) (a), (r)) |
| static inline dom_exception dom_attr_get_specified(struct dom_attr *attr, |
| bool *result) |
| { |
| return ((dom_attr_vtable *) ((dom_node *) attr)->vtable)-> |
| dom_attr_get_specified(attr, result); |
| } |
| #define dom_attr_get_specified(a, r) dom_attr_get_specified( \ |
| (struct dom_attr *) (a), (bool *) (r)) |
| static inline dom_exception dom_attr_get_value(struct dom_attr *attr, |
| dom_string **result) |
| { |
| return ((dom_attr_vtable *) ((dom_node *) attr)->vtable)-> |
| dom_attr_get_value(attr, result); |
| } |
| #define dom_attr_get_value(a, r) dom_attr_get_value((struct dom_attr *) (a), (r)) |
| static inline dom_exception dom_attr_set_value(struct dom_attr *attr, |
| dom_string *value) |
| { |
| return ((dom_attr_vtable *) ((dom_node *) attr)->vtable)-> |
| dom_attr_set_value(attr, value); |
| } |
| #define dom_attr_set_value(a, v) dom_attr_set_value((struct dom_attr *) (a), (v)) |
| static inline dom_exception dom_attr_get_owner_element(struct dom_attr *attr, |
| struct dom_element **result) |
| { |
| return ((dom_attr_vtable *) ((dom_node *) attr)->vtable)-> |
| dom_attr_get_owner_element(attr, result); |
| } |
| #define dom_attr_get_owner_element(a, r) dom_attr_get_owner_element(\ |
| (struct dom_attr *) (a), (struct dom_element **) (r)) |
| static inline dom_exception dom_attr_get_schema_type_info( |
| struct dom_attr *attr, struct dom_type_info **result) |
| { |
| return ((dom_attr_vtable *) ((dom_node *) attr)->vtable)-> |
| dom_attr_get_schema_type_info(attr, result); |
| } |
| #define dom_attr_get_schema_type_info(a, r) dom_attr_get_schema_type_info( \ |
| (struct dom_attr *) (a), (struct dom_type_info **) (r)) |
| static inline dom_exception dom_attr_is_id(struct dom_attr *attr, bool *result) |
| { |
| return ((dom_attr_vtable *) ((dom_node *) attr)->vtable)-> |
| dom_attr_is_id(attr, result); |
| } |
| #define dom_attr_is_id(a, r) dom_attr_is_id((struct dom_attr *) (a), \ |
| (bool *) (r)) |
| /*-----------------------------------------------------------------------*/ |
| /** |
| * Following are our implementation specific APIs. |
| * |
| * These APIs are defined for the purpose that there are some attributes in |
| * HTML and other DOM module whose type is not DOMString, but uint32_t or |
| * boolean, for those types of attributes, clients should call one of the |
| * following APIs to set it. |
| * |
| * When an Attr node is created, its type is unset and it can be turned into |
| * any of the four types. Once the type is fixed by calling any of the four |
| * APIs: |
| * dom_attr_set_value |
| * dom_attr_set_integer |
| * dom_attr_set_short |
| * dom_attr_set_bool |
| * it can't be modified in future. |
| * |
| * For integer/short/bool type of attributes, we provide no string |
| * repensentation of them, so when you call dom_attr_get_value on these |
| * three type of attribute nodes, you will always get a empty dom_string. |
| * If you want to do something with Attr node, you must know its type |
| * firstly by calling dom_attr_get_type before you decide to call other |
| * dom_attr_get_* functions. |
| */ |
| dom_attr_type dom_attr_get_type(dom_attr *a); |
| dom_exception dom_attr_get_integer(dom_attr *a, uint32_t *value); |
| dom_exception dom_attr_set_integer(dom_attr *a, uint32_t value); |
| dom_exception dom_attr_get_short(dom_attr *a, unsigned short *value); |
| dom_exception dom_attr_set_short(dom_attr *a, unsigned short value); |
| dom_exception dom_attr_get_bool(dom_attr *a, bool *value); |
| dom_exception dom_attr_set_bool(dom_attr *a, bool value); |
| /* Make a attribute node readonly */ |
| void dom_attr_mark_readonly(dom_attr *a); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/cdatasection.h |
|---|
| 0,0 → 1,12 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| */ |
| #ifndef dom_core_cdatasection_h_ |
| #define dom_core_cdatasection_h_ |
| typedef struct dom_cdata_section dom_cdata_section; |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/characterdata.h |
|---|
| 0,0 → 1,130 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_characterdata_h_ |
| #define dom_core_characterdata_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/node.h> |
| typedef struct dom_characterdata dom_characterdata; |
| /* The vtable for characterdata */ |
| typedef struct dom_characterdata_vtable { |
| struct dom_node_vtable base; |
| dom_exception (*dom_characterdata_get_data)( |
| struct dom_characterdata *cdata, |
| dom_string **data); |
| dom_exception (*dom_characterdata_set_data)( |
| struct dom_characterdata *cdata, |
| dom_string *data); |
| dom_exception (*dom_characterdata_get_length)( |
| struct dom_characterdata *cdata, |
| uint32_t *length); |
| dom_exception (*dom_characterdata_substring_data)( |
| struct dom_characterdata *cdata, uint32_t offset, |
| uint32_t count, dom_string **data); |
| dom_exception (*dom_characterdata_append_data)( |
| struct dom_characterdata *cdata, |
| dom_string *data); |
| dom_exception (*dom_characterdata_insert_data)( |
| struct dom_characterdata *cdata, |
| uint32_t offset, dom_string *data); |
| dom_exception (*dom_characterdata_delete_data)( |
| struct dom_characterdata *cdata, |
| uint32_t offset, uint32_t count); |
| dom_exception (*dom_characterdata_replace_data)( |
| struct dom_characterdata *cdata, uint32_t offset, |
| uint32_t count, dom_string *data); |
| } dom_characterdata_vtable; |
| static inline dom_exception dom_characterdata_get_data( |
| struct dom_characterdata *cdata, dom_string **data) |
| { |
| return ((dom_characterdata_vtable *) ((dom_node *) cdata)->vtable)-> |
| dom_characterdata_get_data(cdata, data); |
| } |
| #define dom_characterdata_get_data(c, d) dom_characterdata_get_data( \ |
| (struct dom_characterdata *) (c), (d)) |
| static inline dom_exception dom_characterdata_set_data( |
| struct dom_characterdata *cdata, dom_string *data) |
| { |
| return ((dom_characterdata_vtable *) ((dom_node *) cdata)->vtable)-> |
| dom_characterdata_set_data(cdata, data); |
| } |
| #define dom_characterdata_set_data(c, d) dom_characterdata_set_data( \ |
| (struct dom_characterdata *) (c), (d)) |
| static inline dom_exception dom_characterdata_get_length( |
| struct dom_characterdata *cdata, uint32_t *length) |
| { |
| return ((dom_characterdata_vtable *) ((dom_node *) cdata)->vtable)-> |
| dom_characterdata_get_length(cdata, length); |
| } |
| #define dom_characterdata_get_length(c, l) dom_characterdata_get_length( \ |
| (struct dom_characterdata *) (c), (uint32_t *) (l)) |
| static inline dom_exception dom_characterdata_substring_data( |
| struct dom_characterdata *cdata, uint32_t offset, |
| uint32_t count, dom_string **data) |
| { |
| return ((dom_characterdata_vtable *) ((dom_node *) cdata)->vtable)-> |
| dom_characterdata_substring_data(cdata, offset, count, |
| data); |
| } |
| #define dom_characterdata_substring_data(c, o, ct, d) \ |
| dom_characterdata_substring_data( \ |
| (struct dom_characterdata *) (c), (uint32_t) (o), \ |
| (uint32_t) (ct), (d)) |
| static inline dom_exception dom_characterdata_append_data( |
| struct dom_characterdata *cdata, dom_string *data) |
| { |
| return ((dom_characterdata_vtable *) ((dom_node *) cdata)->vtable)-> |
| dom_characterdata_append_data(cdata, data); |
| } |
| #define dom_characterdata_append_data(c, d) dom_characterdata_append_data( \ |
| (struct dom_characterdata *) (c), (d)) |
| static inline dom_exception dom_characterdata_insert_data( |
| struct dom_characterdata *cdata, uint32_t offset, |
| dom_string *data) |
| { |
| return ((dom_characterdata_vtable *) ((dom_node *) cdata)->vtable)-> |
| dom_characterdata_insert_data(cdata, offset, data); |
| } |
| #define dom_characterdata_insert_data(c, o, d) dom_characterdata_insert_data( \ |
| (struct dom_characterdata *) (c), (uint32_t) (o), (d)) |
| static inline dom_exception dom_characterdata_delete_data( |
| struct dom_characterdata *cdata, uint32_t offset, |
| uint32_t count) |
| { |
| return ((dom_characterdata_vtable *) ((dom_node *) cdata)->vtable)-> |
| dom_characterdata_delete_data(cdata, offset, count); |
| } |
| #define dom_characterdata_delete_data(c, o, ct) dom_characterdata_delete_data(\ |
| (struct dom_characterdata *) (c), (uint32_t) (o), \ |
| (uint32_t) (ct)) |
| static inline dom_exception dom_characterdata_replace_data( |
| struct dom_characterdata *cdata, uint32_t offset, |
| uint32_t count, dom_string *data) |
| { |
| return ((dom_characterdata_vtable *) ((dom_node *) cdata)->vtable)-> |
| dom_characterdata_replace_data(cdata, offset, count, |
| data); |
| } |
| #define dom_characterdata_replace_data(c, o, ct, d) \ |
| dom_characterdata_replace_data(\ |
| (struct dom_characterdata *) (c), (uint32_t) (o),\ |
| (uint32_t) (ct), (d)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/comment.h |
|---|
| 0,0 → 1,18 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_core_comment_h_ |
| #define dom_core_comment_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/characterdata.h> |
| typedef struct dom_comment dom_comment; |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/doc_fragment.h |
|---|
| 0,0 → 1,12 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| */ |
| #ifndef dom_core_documentfragment_h_ |
| #define dom_core_documentfragment_h_ |
| typedef struct dom_document_fragment dom_document_fragment; |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/document.h |
|---|
| 0,0 → 1,471 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_document_h_ |
| #define dom_core_document_h_ |
| #include <stdbool.h> |
| #include <inttypes.h> |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/implementation.h> |
| #include <dom/core/node.h> |
| struct dom_attr; |
| struct dom_cdata_section; |
| struct dom_characterdata; |
| struct dom_comment; |
| struct dom_configuration; |
| struct dom_document_fragment; |
| struct dom_document_type; |
| struct dom_element; |
| struct dom_entity_reference; |
| struct dom_node; |
| struct dom_nodelist; |
| struct dom_processing_instruction; |
| struct dom_text; |
| struct lwc_string_s; |
| typedef struct dom_document dom_document; |
| /** |
| * Quirks mode flag |
| */ |
| typedef enum dom_document_quirks_mode { |
| DOM_DOCUMENT_QUIRKS_MODE_NONE, |
| DOM_DOCUMENT_QUIRKS_MODE_LIMITED, |
| DOM_DOCUMENT_QUIRKS_MODE_FULL |
| } dom_document_quirks_mode; |
| /* DOM Document vtable */ |
| typedef struct dom_document_vtable { |
| struct dom_node_vtable base; |
| dom_exception (*dom_document_get_doctype)(struct dom_document *doc, |
| struct dom_document_type **result); |
| dom_exception (*dom_document_get_implementation)( |
| struct dom_document *doc, |
| dom_implementation **result); |
| dom_exception (*dom_document_get_document_element)( |
| struct dom_document *doc, struct dom_element **result); |
| dom_exception (*dom_document_create_element)(struct dom_document *doc, |
| dom_string *tag_name, |
| struct dom_element **result); |
| dom_exception (*dom_document_create_document_fragment)( |
| struct dom_document *doc, |
| struct dom_document_fragment **result); |
| dom_exception (*dom_document_create_text_node)(struct dom_document *doc, |
| dom_string *data, struct dom_text **result); |
| dom_exception (*dom_document_create_comment)(struct dom_document *doc, |
| dom_string *data, struct dom_comment **result); |
| dom_exception (*dom_document_create_cdata_section)( |
| struct dom_document *doc, dom_string *data, |
| struct dom_cdata_section **result); |
| dom_exception (*dom_document_create_processing_instruction)( |
| struct dom_document *doc, dom_string *target, |
| dom_string *data, |
| struct dom_processing_instruction **result); |
| dom_exception (*dom_document_create_attribute)(struct dom_document *doc, |
| dom_string *name, struct dom_attr **result); |
| dom_exception (*dom_document_create_entity_reference)( |
| struct dom_document *doc, dom_string *name, |
| struct dom_entity_reference **result); |
| dom_exception (*dom_document_get_elements_by_tag_name)( |
| struct dom_document *doc, dom_string *tagname, |
| struct dom_nodelist **result); |
| dom_exception (*dom_document_import_node)(struct dom_document *doc, |
| struct dom_node *node, bool deep, |
| struct dom_node **result); |
| dom_exception (*dom_document_create_element_ns)( |
| struct dom_document *doc, dom_string *namespace, |
| dom_string *qname, struct dom_element **result); |
| dom_exception (*dom_document_create_attribute_ns)( |
| struct dom_document *doc, dom_string *namespace, |
| dom_string *qname, struct dom_attr **result); |
| dom_exception (*dom_document_get_elements_by_tag_name_ns)( |
| struct dom_document *doc, dom_string *namespace, |
| dom_string *localname, |
| struct dom_nodelist **result); |
| dom_exception (*dom_document_get_element_by_id)( |
| struct dom_document *doc, dom_string *id, |
| struct dom_element **result); |
| dom_exception (*dom_document_get_input_encoding)( |
| struct dom_document *doc, dom_string **result); |
| dom_exception (*dom_document_get_xml_encoding)(struct dom_document *doc, |
| dom_string **result); |
| dom_exception (*dom_document_get_xml_standalone)( |
| struct dom_document *doc, bool *result); |
| dom_exception (*dom_document_set_xml_standalone)( |
| struct dom_document *doc, bool standalone); |
| dom_exception (*dom_document_get_xml_version)(struct dom_document *doc, |
| dom_string **result); |
| dom_exception (*dom_document_set_xml_version)(struct dom_document *doc, |
| dom_string *version); |
| dom_exception (*dom_document_get_strict_error_checking)( |
| struct dom_document *doc, bool *result); |
| dom_exception (*dom_document_set_strict_error_checking)( |
| struct dom_document *doc, bool strict); |
| dom_exception (*dom_document_get_uri)(struct dom_document *doc, |
| dom_string **result); |
| dom_exception (*dom_document_set_uri)(struct dom_document *doc, |
| dom_string *uri); |
| dom_exception (*dom_document_adopt_node)(struct dom_document *doc, |
| struct dom_node *node, struct dom_node **result); |
| dom_exception (*dom_document_get_dom_config)(struct dom_document *doc, |
| struct dom_configuration **result); |
| dom_exception (*dom_document_normalize)(struct dom_document *doc); |
| dom_exception (*dom_document_rename_node)(struct dom_document *doc, |
| struct dom_node *node, dom_string *namespace, |
| dom_string *qname, struct dom_node **result); |
| dom_exception (*get_quirks_mode)(dom_document *doc, |
| dom_document_quirks_mode *result); |
| dom_exception (*set_quirks_mode)(dom_document *doc, |
| dom_document_quirks_mode quirks); |
| } dom_document_vtable; |
| static inline dom_exception dom_document_get_doctype(struct dom_document *doc, |
| struct dom_document_type **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_doctype(doc, result); |
| } |
| #define dom_document_get_doctype(d, r) dom_document_get_doctype( \ |
| (dom_document *) (d), (struct dom_document_type **) (r)) |
| static inline dom_exception dom_document_get_implementation( |
| struct dom_document *doc, dom_implementation **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_implementation(doc, result); |
| } |
| #define dom_document_get_implementation(d, r) dom_document_get_implementation(\ |
| (dom_document *) (d), (dom_implementation **) (r)) |
| static inline dom_exception dom_document_get_document_element( |
| struct dom_document *doc, struct dom_element **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_document_element(doc, result); |
| } |
| #define dom_document_get_document_element(d, r) \ |
| dom_document_get_document_element((dom_document *) (d), \ |
| (struct dom_element **) (r)) |
| static inline dom_exception dom_document_create_element( |
| struct dom_document *doc, dom_string *tag_name, |
| struct dom_element **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_create_element(doc, tag_name, result); |
| } |
| #define dom_document_create_element(d, t, r) dom_document_create_element( \ |
| (dom_document *) (d), (t), \ |
| (struct dom_element **) (r)) |
| static inline dom_exception dom_document_create_document_fragment( |
| struct dom_document *doc, |
| struct dom_document_fragment **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_create_document_fragment(doc, result); |
| } |
| #define dom_document_create_document_fragment(d, r) \ |
| dom_document_create_document_fragment((dom_document *) (d), \ |
| (struct dom_document_fragment **) (r)) |
| static inline dom_exception dom_document_create_text_node( |
| struct dom_document *doc, dom_string *data, |
| struct dom_text **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_create_text_node(doc, data, result); |
| } |
| #define dom_document_create_text_node(d, data, r) \ |
| dom_document_create_text_node((dom_document *) (d), \ |
| (data), (struct dom_text **) (r)) |
| static inline dom_exception dom_document_create_comment( |
| struct dom_document *doc, dom_string *data, |
| struct dom_comment **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_create_comment(doc, data, result); |
| } |
| #define dom_document_create_comment(d, data, r) dom_document_create_comment( \ |
| (dom_document *) (d), (data), \ |
| (struct dom_comment **) (r)) |
| static inline dom_exception dom_document_create_cdata_section( |
| struct dom_document *doc, dom_string *data, |
| struct dom_cdata_section **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_create_cdata_section(doc, data, result); |
| } |
| #define dom_document_create_cdata_section(d, data, r) \ |
| dom_document_create_cdata_section((dom_document *) (d), \ |
| (data), (struct dom_cdata_section **) (r)) |
| static inline dom_exception dom_document_create_processing_instruction( |
| struct dom_document *doc, dom_string *target, |
| dom_string *data, |
| struct dom_processing_instruction **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_create_processing_instruction(doc, target, |
| data, result); |
| } |
| #define dom_document_create_processing_instruction(d, t, data, r) \ |
| dom_document_create_processing_instruction( \ |
| (dom_document *) (d), (t), (data), \ |
| (struct dom_processing_instruction **) (r)) |
| static inline dom_exception dom_document_create_attribute( |
| struct dom_document *doc, dom_string *name, |
| struct dom_attr **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_create_attribute(doc, name, result); |
| } |
| #define dom_document_create_attribute(d, n, r) dom_document_create_attribute( \ |
| (dom_document *) (d), (n), \ |
| (struct dom_attr **) (r)) |
| static inline dom_exception dom_document_create_entity_reference( |
| struct dom_document *doc, dom_string *name, |
| struct dom_entity_reference **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_create_entity_reference(doc, name, |
| result); |
| } |
| #define dom_document_create_entity_reference(d, n, r) \ |
| dom_document_create_entity_reference((dom_document *) (d), \ |
| (n), (struct dom_entity_reference **) (r)) |
| static inline dom_exception dom_document_get_elements_by_tag_name( |
| struct dom_document *doc, dom_string *tagname, |
| struct dom_nodelist **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_elements_by_tag_name(doc, tagname, |
| result); |
| } |
| #define dom_document_get_elements_by_tag_name(d, t, r) \ |
| dom_document_get_elements_by_tag_name((dom_document *) (d), \ |
| (t), (struct dom_nodelist **) (r)) |
| static inline dom_exception dom_document_import_node(struct dom_document *doc, |
| struct dom_node *node, bool deep, struct dom_node **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_import_node(doc, node, deep, result); |
| } |
| #define dom_document_import_node(d, n, deep, r) dom_document_import_node( \ |
| (dom_document *) (d), (dom_node *) (n), (bool) deep, \ |
| (dom_node **) (r)) |
| static inline dom_exception dom_document_create_element_ns( |
| struct dom_document *doc, dom_string *namespace, |
| dom_string *qname, struct dom_element **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_create_element_ns(doc, namespace, |
| qname, result); |
| } |
| #define dom_document_create_element_ns(d, n, q, r) \ |
| dom_document_create_element_ns((dom_document *) (d), \ |
| (n), (q), \ |
| (struct dom_element **) (r)) |
| static inline dom_exception dom_document_create_attribute_ns |
| (struct dom_document *doc, dom_string *namespace, |
| dom_string *qname, struct dom_attr **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_create_attribute_ns(doc, namespace, |
| qname, result); |
| } |
| #define dom_document_create_attribute_ns(d, n, q, r) \ |
| dom_document_create_attribute_ns((dom_document *) (d), \ |
| (n), (q), (struct dom_attr **) (r)) |
| static inline dom_exception dom_document_get_elements_by_tag_name_ns( |
| struct dom_document *doc, dom_string *namespace, |
| dom_string *localname, struct dom_nodelist **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_elements_by_tag_name_ns(doc, |
| namespace, localname, result); |
| } |
| #define dom_document_get_elements_by_tag_name_ns(d, n, l, r) \ |
| dom_document_get_elements_by_tag_name_ns((dom_document *) (d),\ |
| (n), (l), (struct dom_nodelist **) (r)) |
| static inline dom_exception dom_document_get_element_by_id( |
| struct dom_document *doc, dom_string *id, |
| struct dom_element **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_element_by_id(doc, id, result); |
| } |
| #define dom_document_get_element_by_id(d, i, r) \ |
| dom_document_get_element_by_id((dom_document *) (d), \ |
| (i), (struct dom_element **) (r)) |
| static inline dom_exception dom_document_get_input_encoding( |
| struct dom_document *doc, dom_string **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_input_encoding(doc, result); |
| } |
| #define dom_document_get_input_encoding(d, r) dom_document_get_input_encoding(\ |
| (dom_document *) (d), (r)) |
| static inline dom_exception dom_document_get_xml_encoding( |
| struct dom_document *doc, dom_string **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_xml_encoding(doc, result); |
| } |
| #define dom_document_get_xml_encoding(d, r) dom_document_get_xml_encoding( \ |
| (dom_document *) (d), (r)) |
| static inline dom_exception dom_document_get_xml_standalone( |
| struct dom_document *doc, bool *result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_xml_standalone(doc, result); |
| } |
| #define dom_document_get_xml_standalone(d, r) dom_document_get_xml_standalone(\ |
| (dom_document *) (d), (bool *) (r)) |
| static inline dom_exception dom_document_set_xml_standalone( |
| struct dom_document *doc, bool standalone) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_set_xml_standalone(doc, standalone); |
| } |
| #define dom_document_set_xml_standalone(d, s) dom_document_set_xml_standalone(\ |
| (dom_document *) (d), (bool) (s)) |
| static inline dom_exception dom_document_get_xml_version( |
| struct dom_document *doc, dom_string **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_xml_version(doc, result); |
| } |
| #define dom_document_get_xml_version(d, r) dom_document_get_xml_version( \ |
| (dom_document *) (d), (r)) |
| static inline dom_exception dom_document_set_xml_version( |
| struct dom_document *doc, dom_string *version) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_set_xml_version(doc, version); |
| } |
| #define dom_document_set_xml_version(d, v) dom_document_set_xml_version( \ |
| (dom_document *) (d), (v)) |
| static inline dom_exception dom_document_get_strict_error_checking( |
| struct dom_document *doc, bool *result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_strict_error_checking(doc, result); |
| } |
| #define dom_document_get_strict_error_checking(d, r) \ |
| dom_document_get_strict_error_checking((dom_document *) (d), \ |
| (bool *) (r)) |
| static inline dom_exception dom_document_set_strict_error_checking( |
| struct dom_document *doc, bool strict) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_set_strict_error_checking(doc, strict); |
| } |
| #define dom_document_set_strict_error_checking(d, s) \ |
| dom_document_set_strict_error_checking((dom_document *) (d), \ |
| (bool) (s)) |
| static inline dom_exception dom_document_get_uri(struct dom_document *doc, |
| dom_string **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_uri(doc, result); |
| } |
| #define dom_document_get_uri(d, r) dom_document_get_uri((dom_document *) (d), \ |
| (r)) |
| static inline dom_exception dom_document_set_uri(struct dom_document *doc, |
| dom_string *uri) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_set_uri(doc, uri); |
| } |
| #define dom_document_set_uri(d, u) dom_document_set_uri((dom_document *) (d), \ |
| (u)) |
| static inline dom_exception dom_document_adopt_node(struct dom_document *doc, |
| struct dom_node *node, struct dom_node **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_adopt_node(doc, node, result); |
| } |
| #define dom_document_adopt_node(d, n, r) dom_document_adopt_node( \ |
| (dom_document *) (d), (dom_node *) (n), (dom_node **) (r)) |
| static inline dom_exception dom_document_get_dom_config( |
| struct dom_document *doc, struct dom_configuration **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_get_dom_config(doc, result); |
| } |
| #define dom_document_get_dom_config(d, r) dom_document_get_dom_config( \ |
| (dom_document *) (d), (struct dom_configuration **) (r)) |
| static inline dom_exception dom_document_normalize(struct dom_document *doc) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_normalize(doc); |
| } |
| #define dom_document_normalize(d) dom_document_normalize((dom_document *) (d)) |
| static inline dom_exception dom_document_rename_node(struct dom_document *doc, |
| struct dom_node *node, |
| dom_string *namespace, dom_string *qname, |
| struct dom_node **result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| dom_document_rename_node(doc, node, namespace, qname, |
| result); |
| } |
| #define dom_document_rename_node(d, n, ns, q, r) dom_document_rename_node( \ |
| (dom_document *) (d), (ns), \ |
| (q), (dom_node **) (r)) |
| static inline dom_exception dom_document_get_quirks_mode( |
| dom_document *doc, dom_document_quirks_mode *result) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_quirks_mode(doc, result); |
| } |
| #define dom_document_get_quirks_mode(d, r) \ |
| dom_document_get_quirks_mode((dom_document *) (d), (r)) |
| static inline dom_exception dom_document_set_quirks_mode( |
| dom_document *doc, dom_document_quirks_mode quirks) |
| { |
| return ((dom_document_vtable *) ((dom_node *) doc)->vtable)-> |
| set_quirks_mode(doc, quirks); |
| } |
| #define dom_document_set_quirks_mode(d, q) \ |
| dom_document_set_quirks_mode((dom_document *) (d), (q)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/document_type.h |
|---|
| 0,0 → 1,106 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2007 James Shaw <jshaw@netsurf-browser.org> |
| */ |
| #ifndef dom_core_document_type_h_ |
| #define dom_core_document_type_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/node.h> |
| struct dom_namednodemap; |
| typedef struct dom_document_type dom_document_type; |
| /* The Dom DocumentType vtable */ |
| typedef struct dom_document_type_vtable { |
| struct dom_node_vtable base; |
| dom_exception (*dom_document_type_get_name)( |
| struct dom_document_type *doc_type, |
| dom_string **result); |
| dom_exception (*dom_document_type_get_entities)( |
| struct dom_document_type *doc_type, |
| struct dom_namednodemap **result); |
| dom_exception (*dom_document_type_get_notations)( |
| struct dom_document_type *doc_type, |
| struct dom_namednodemap **result); |
| dom_exception (*dom_document_type_get_public_id)( |
| struct dom_document_type *doc_type, |
| dom_string **result); |
| dom_exception (*dom_document_type_get_system_id)( |
| struct dom_document_type *doc_type, |
| dom_string **result); |
| dom_exception (*dom_document_type_get_internal_subset)( |
| struct dom_document_type *doc_type, |
| dom_string **result); |
| } dom_document_type_vtable; |
| static inline dom_exception dom_document_type_get_name( |
| struct dom_document_type *doc_type, dom_string **result) |
| { |
| return ((dom_document_type_vtable *) ((dom_node *) (doc_type))->vtable) |
| ->dom_document_type_get_name(doc_type, result); |
| } |
| #define dom_document_type_get_name(dt, r) dom_document_type_get_name( \ |
| (dom_document_type *) (dt), (r)) |
| static inline dom_exception dom_document_type_get_entities( |
| struct dom_document_type *doc_type, |
| struct dom_namednodemap **result) |
| { |
| return ((dom_document_type_vtable *) ((dom_node *) (doc_type))->vtable) |
| ->dom_document_type_get_entities(doc_type, result); |
| } |
| #define dom_document_type_get_entities(dt, r) dom_document_type_get_entities( \ |
| (dom_document_type *) (dt), (struct dom_namednodemap **) (r)) |
| static inline dom_exception dom_document_type_get_notations( |
| struct dom_document_type *doc_type, |
| struct dom_namednodemap **result) |
| { |
| return ((dom_document_type_vtable *) ((dom_node *) (doc_type))->vtable) |
| ->dom_document_type_get_notations(doc_type, result); |
| } |
| #define dom_document_type_get_notations(dt, r) dom_document_type_get_notations(\ |
| (dom_document_type *) (dt), (struct dom_namednodemap **) (r)) |
| static inline dom_exception dom_document_type_get_public_id( |
| struct dom_document_type *doc_type, |
| dom_string **result) |
| { |
| return ((dom_document_type_vtable *) ((dom_node *) (doc_type))->vtable) |
| ->dom_document_type_get_public_id(doc_type, result); |
| } |
| #define dom_document_type_get_public_id(dt, r) \ |
| dom_document_type_get_public_id((dom_document_type *) (dt), \ |
| (r)) |
| static inline dom_exception dom_document_type_get_system_id( |
| struct dom_document_type *doc_type, |
| dom_string **result) |
| { |
| return ((dom_document_type_vtable *) ((dom_node *) (doc_type))->vtable) |
| ->dom_document_type_get_system_id(doc_type, result); |
| } |
| #define dom_document_type_get_system_id(dt, r) \ |
| dom_document_type_get_system_id((dom_document_type *) (dt), \ |
| (r)) |
| static inline dom_exception dom_document_type_get_internal_subset( |
| struct dom_document_type *doc_type, |
| dom_string **result) |
| { |
| return ((dom_document_type_vtable *) ((dom_node *) (doc_type))->vtable) |
| ->dom_document_type_get_internal_subset(doc_type, |
| result); |
| } |
| #define dom_document_type_get_internal_subset(dt, r) \ |
| dom_document_type_get_internal_subset( \ |
| (dom_document_type *) (dt), (r)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/element.h |
|---|
| 0,0 → 1,359 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_element_h_ |
| #define dom_core_element_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/node.h> |
| struct dom_attr; |
| struct dom_nodelist; |
| struct dom_type_info; |
| typedef struct dom_element dom_element; |
| /* The DOMElement vtable */ |
| typedef struct dom_element_vtable { |
| struct dom_node_vtable base; |
| dom_exception (*dom_element_get_tag_name)(struct dom_element *element, |
| dom_string **name); |
| dom_exception (*dom_element_get_attribute)(struct dom_element *element, |
| dom_string *name, dom_string **value); |
| dom_exception (*dom_element_set_attribute)(struct dom_element *element, |
| dom_string *name, dom_string *value); |
| dom_exception (*dom_element_remove_attribute)( |
| struct dom_element *element, dom_string *name); |
| dom_exception (*dom_element_get_attribute_node)( |
| struct dom_element *element, dom_string *name, |
| struct dom_attr **result); |
| dom_exception (*dom_element_set_attribute_node)( |
| struct dom_element *element, struct dom_attr *attr, |
| struct dom_attr **result); |
| dom_exception (*dom_element_remove_attribute_node)( |
| struct dom_element *element, struct dom_attr *attr, |
| struct dom_attr **result); |
| dom_exception (*dom_element_get_elements_by_tag_name)( |
| struct dom_element *element, dom_string *name, |
| struct dom_nodelist **result); |
| dom_exception (*dom_element_get_attribute_ns)( |
| struct dom_element *element, |
| dom_string *namespace, |
| dom_string *localname, |
| dom_string **value); |
| dom_exception (*dom_element_set_attribute_ns)( |
| struct dom_element *element, |
| dom_string *namespace, dom_string *qname, |
| dom_string *value); |
| dom_exception (*dom_element_remove_attribute_ns)( |
| struct dom_element *element, |
| dom_string *namespace, |
| dom_string *localname); |
| dom_exception (*dom_element_get_attribute_node_ns)( |
| struct dom_element *element, |
| dom_string *namespace, |
| dom_string *localname, struct dom_attr **result); |
| dom_exception (*dom_element_set_attribute_node_ns)( |
| struct dom_element *element, struct dom_attr *attr, |
| struct dom_attr **result); |
| dom_exception (*dom_element_get_elements_by_tag_name_ns)( |
| struct dom_element *element, |
| dom_string *namespace, |
| dom_string *localname, |
| struct dom_nodelist **result); |
| dom_exception (*dom_element_has_attribute)(struct dom_element *element, |
| dom_string *name, bool *result); |
| dom_exception (*dom_element_has_attribute_ns)( |
| struct dom_element *element, |
| dom_string *namespace, |
| dom_string *localname, bool *result); |
| dom_exception (*dom_element_get_schema_type_info)( |
| struct dom_element *element, |
| struct dom_type_info **result); |
| dom_exception (*dom_element_set_id_attribute)( |
| struct dom_element *element, dom_string *name, |
| bool is_id); |
| dom_exception (*dom_element_set_id_attribute_ns)( |
| struct dom_element *element, |
| dom_string *namespace, |
| dom_string *localname, bool is_id); |
| dom_exception (*dom_element_set_id_attribute_node)( |
| struct dom_element *element, |
| struct dom_attr *id_attr, bool is_id); |
| /* These two are for the benefit of bindings to libcss */ |
| dom_exception (*dom_element_get_classes)( |
| struct dom_element *element, |
| lwc_string ***classes, uint32_t *n_classes); |
| dom_exception (*dom_element_has_class)( |
| struct dom_element *element, |
| lwc_string *name, bool *match); |
| } dom_element_vtable; |
| static inline dom_exception dom_element_get_tag_name( |
| struct dom_element *element, dom_string **name) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_get_tag_name(element, name); |
| } |
| #define dom_element_get_tag_name(e, n) dom_element_get_tag_name( \ |
| (dom_element *) (e), (n)) |
| static inline dom_exception dom_element_get_attribute( |
| struct dom_element *element, dom_string *name, |
| dom_string **value) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_get_attribute(element, name, value); |
| } |
| #define dom_element_get_attribute(e, n, v) dom_element_get_attribute( \ |
| (dom_element *) (e), (n), (v)) |
| static inline dom_exception dom_element_set_attribute( |
| struct dom_element *element, dom_string *name, |
| dom_string *value) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_set_attribute(element, name, value); |
| } |
| #define dom_element_set_attribute(e, n, v) dom_element_set_attribute( \ |
| (dom_element *) (e), (n), (v)) |
| static inline dom_exception dom_element_remove_attribute( |
| struct dom_element *element, dom_string *name) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_remove_attribute(element, name); |
| } |
| #define dom_element_remove_attribute(e, n) dom_element_remove_attribute( \ |
| (dom_element *) (e), (n)) |
| static inline dom_exception dom_element_get_attribute_node( |
| struct dom_element *element, dom_string *name, |
| struct dom_attr **result) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_get_attribute_node(element, name, result); |
| } |
| #define dom_element_get_attribute_node(e, n, r) \ |
| dom_element_get_attribute_node((dom_element *) (e), \ |
| (n), (struct dom_attr **) (r)) |
| static inline dom_exception dom_element_set_attribute_node( |
| struct dom_element *element, struct dom_attr *attr, |
| struct dom_attr **result) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_set_attribute_node(element, attr, result); |
| } |
| #define dom_element_set_attribute_node(e, a, r) \ |
| dom_element_set_attribute_node((dom_element *) (e), \ |
| (struct dom_attr *) (a), (struct dom_attr **) (r)) |
| static inline dom_exception dom_element_remove_attribute_node( |
| struct dom_element *element, struct dom_attr *attr, |
| struct dom_attr **result) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_remove_attribute_node(element, attr, |
| result); |
| } |
| #define dom_element_remove_attribute_node(e, a, r) \ |
| dom_element_remove_attribute_node((dom_element *) (e), \ |
| (struct dom_attr *) (a), (struct dom_attr **) (r)) |
| static inline dom_exception dom_element_get_elements_by_tag_name( |
| struct dom_element *element, dom_string *name, |
| struct dom_nodelist **result) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_get_elements_by_tag_name(element, name, |
| result); |
| } |
| #define dom_element_get_elements_by_tag_name(e, n, r) \ |
| dom_element_get_elements_by_tag_name((dom_element *) (e), \ |
| (n), (struct dom_nodelist **) (r)) |
| static inline dom_exception dom_element_get_attribute_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *localname, dom_string **value) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_get_attribute_ns(element, namespace, |
| localname, value); |
| } |
| #define dom_element_get_attribute_ns(e, n, l, v) \ |
| dom_element_get_attribute_ns((dom_element *) (e), \ |
| (n), (l), (v)) |
| static inline dom_exception dom_element_set_attribute_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *qname, dom_string *value) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_set_attribute_ns(element, namespace, |
| qname, value); |
| } |
| #define dom_element_set_attribute_ns(e, n, l, v) \ |
| dom_element_set_attribute_ns((dom_element *) (e), \ |
| (n), (l), (v)) |
| static inline dom_exception dom_element_remove_attribute_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *localname) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_remove_attribute_ns(element, namespace, |
| localname); |
| } |
| #define dom_element_remove_attribute_ns(e, n, l) \ |
| dom_element_remove_attribute_ns((dom_element *) (e), \ |
| (n), (l)) |
| static inline dom_exception dom_element_get_attribute_node_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *localname, struct dom_attr **result) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_get_attribute_node_ns(element, namespace, |
| localname, result); |
| } |
| #define dom_element_get_attribute_node_ns(e, n, l, r) \ |
| dom_element_get_attribute_node_ns((dom_element *) (e), \ |
| (n), (l), \ |
| (struct dom_attr **) (r)) |
| static inline dom_exception dom_element_set_attribute_node_ns( |
| struct dom_element *element, struct dom_attr *attr, |
| struct dom_attr **result) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_set_attribute_node_ns(element, attr, |
| result); |
| } |
| #define dom_element_set_attribute_node_ns(e, a, r) \ |
| dom_element_set_attribute_node_ns((dom_element *) (e), \ |
| (struct dom_attr *) (a), (struct dom_attr **) (r)) |
| static inline dom_exception dom_element_get_elements_by_tag_name_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *localname, struct dom_nodelist **result) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_get_elements_by_tag_name_ns(element, |
| namespace, localname, result); |
| } |
| #define dom_element_get_elements_by_tag_name_ns(e, n, l, r) \ |
| dom_element_get_elements_by_tag_name_ns((dom_element *) (e), \ |
| (n), (l), (struct dom_nodelist **) (r)) |
| static inline dom_exception dom_element_has_attribute( |
| struct dom_element *element, dom_string *name, |
| bool *result) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_has_attribute(element, name, result); |
| } |
| #define dom_element_has_attribute(e, n, r) dom_element_has_attribute( \ |
| (dom_element *) (e), (n), (bool *) (r)) |
| static inline dom_exception dom_element_has_attribute_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *localname, bool *result) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_has_attribute_ns(element, namespace, |
| localname, result); |
| } |
| #define dom_element_has_attribute_ns(e, n, l, r) dom_element_has_attribute_ns(\ |
| (dom_element *) (e), (n), (l), (bool *) (r)) |
| static inline dom_exception dom_element_get_schema_type_info( |
| struct dom_element *element, struct dom_type_info **result) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_get_schema_type_info(element, result); |
| } |
| #define dom_element_get_schema_type_info(e, r) \ |
| dom_element_get_schema_type_info((dom_element *) (e), \ |
| (struct dom_type_info **) (r)) |
| static inline dom_exception dom_element_set_id_attribute( |
| struct dom_element *element, dom_string *name, |
| bool is_id) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_set_id_attribute(element, name, is_id); |
| } |
| #define dom_element_set_id_attribute(e, n, i) \ |
| dom_element_set_id_attribute((dom_element *) (e), \ |
| (n), (bool) (i)) |
| static inline dom_exception dom_element_set_id_attribute_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *localname, bool is_id) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_set_id_attribute_ns(element, namespace, |
| localname, is_id); |
| } |
| #define dom_element_set_id_attribute_ns(e, n, l, i) \ |
| dom_element_set_id_attribute_ns((dom_element *) (e), \ |
| (n), (l), (bool) (i)) |
| static inline dom_exception dom_element_set_id_attribute_node( |
| struct dom_element *element, struct dom_attr *id_attr, |
| bool is_id) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_set_id_attribute_node(element, id_attr, |
| is_id); |
| } |
| #define dom_element_set_id_attribute_node(e, a, i) \ |
| dom_element_set_id_attribute_node((dom_element *) (e), \ |
| (struct dom_attr *) (a), (bool) (i)) |
| static inline dom_exception dom_element_get_classes( |
| struct dom_element *element, |
| lwc_string ***classes, uint32_t *n_classes) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_get_classes(element, classes, n_classes); |
| } |
| #define dom_element_get_classes(e, c, n) \ |
| dom_element_get_classes((dom_element *) (e), \ |
| (lwc_string ***) (c), (uint32_t *) (n)) |
| static inline dom_exception dom_element_has_class( |
| struct dom_element *element, lwc_string *name, bool *match) |
| { |
| return ((dom_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_element_has_class(element, name, match); |
| } |
| #define dom_element_has_class(e, n, m) \ |
| dom_element_has_class((dom_element *) (e), \ |
| (lwc_string *) (n), (bool *) (m)) |
| /* Functions for implementing some libcss selection callbacks. |
| * Note that they don't take a reference to the returned element, as such they |
| * are UNSAFE if you require the returned element to live beyond the next time |
| * the DOM gets a chance to change. */ |
| dom_exception dom_element_named_ancestor_node(dom_element *element, |
| lwc_string *name, dom_element **ancestor); |
| dom_exception dom_element_named_parent_node(dom_element *element, |
| lwc_string *name, dom_element **parent); |
| dom_exception dom_element_parent_node(dom_element *element, |
| dom_element **parent); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/entity_ref.h |
|---|
| 0,0 → 1,13 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_entityreference_h_ |
| #define dom_core_entityreference_h_ |
| typedef struct dom_entity_reference dom_entity_reference; |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/exceptions.h |
|---|
| 0,0 → 1,52 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_exceptions_h_ |
| #define dom_core_exceptions_h_ |
| /** |
| * Class of a DOM exception. |
| * |
| * The top 16 bits of a dom_exception are a bitfield |
| * indicating which class the exception belongs to. |
| */ |
| typedef enum { |
| DOM_EXCEPTION_CLASS_NORMAL = 0, |
| DOM_EXCEPTION_CLASS_EVENT = (1<<30), |
| DOM_EXCEPTION_CLASS_INTERNAL = (1<<31) |
| } dom_exception_class; |
| /* The DOM spec says that this is actually an unsigned short */ |
| typedef enum { |
| DOM_NO_ERR = 0, |
| DOM_INDEX_SIZE_ERR = 1, |
| DOM_DOMSTRING_SIZE_ERR = 2, |
| DOM_HIERARCHY_REQUEST_ERR = 3, |
| DOM_WRONG_DOCUMENT_ERR = 4, |
| DOM_INVALID_CHARACTER_ERR = 5, |
| DOM_NO_DATA_ALLOWED_ERR = 6, |
| DOM_NO_MODIFICATION_ALLOWED_ERR = 7, |
| DOM_NOT_FOUND_ERR = 8, |
| DOM_NOT_SUPPORTED_ERR = 9, |
| DOM_INUSE_ATTRIBUTE_ERR = 10, |
| DOM_INVALID_STATE_ERR = 11, |
| DOM_SYNTAX_ERR = 12, |
| DOM_INVALID_MODIFICATION_ERR = 13, |
| DOM_NAMESPACE_ERR = 14, |
| DOM_INVALID_ACCESS_ERR = 15, |
| DOM_VALIDATION_ERR = 16, |
| DOM_TYPE_MISMATCH_ERR = 17, |
| DOM_UNSPECIFIED_EVENT_TYPE_ERR = DOM_EXCEPTION_CLASS_EVENT + 0, |
| DOM_DISPATCH_REQUEST_ERR = DOM_EXCEPTION_CLASS_EVENT + 1, |
| DOM_NO_MEM_ERR = DOM_EXCEPTION_CLASS_INTERNAL + 0, |
| DOM_ATTR_WRONG_TYPE_ERR = DOM_EXCEPTION_CLASS_INTERNAL + 1 |
| /* our own internal error */ |
| } dom_exception; |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/implementation.h |
|---|
| 0,0 → 1,53 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_implementation_h_ |
| #define dom_core_implementation_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/events/document_event.h> |
| #include <dom/functypes.h> |
| struct dom_document; |
| struct dom_document_type; |
| typedef const char dom_implementation; |
| typedef enum dom_implementation_type { |
| DOM_IMPLEMENTATION_CORE = 0, |
| DOM_IMPLEMENTATION_XML = (1 << 0), /* not implemented */ |
| DOM_IMPLEMENTATION_HTML = (1 << 1), |
| DOM_IMPLEMENTATION_ALL = DOM_IMPLEMENTATION_CORE | |
| DOM_IMPLEMENTATION_XML | |
| DOM_IMPLEMENTATION_HTML |
| } dom_implementation_type; |
| dom_exception dom_implementation_has_feature( |
| const char *feature, const char *version, |
| bool *result); |
| dom_exception dom_implementation_create_document_type( |
| const char *qname, |
| const char *public_id, const char *system_id, |
| struct dom_document_type **doctype); |
| dom_exception dom_implementation_create_document( |
| uint32_t impl_type, |
| const char *namespace, const char *qname, |
| struct dom_document_type *doctype, |
| dom_events_default_action_fetcher daf, |
| void *daf_ctx, |
| struct dom_document **doc); |
| dom_exception dom_implementation_get_feature( |
| const char *feature, const char *version, |
| void **object); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/namednodemap.h |
|---|
| 0,0 → 1,83 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_namednodemap_h_ |
| #define dom_core_namednodemap_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_node; |
| typedef struct dom_namednodemap dom_namednodemap; |
| void dom_namednodemap_ref(struct dom_namednodemap *map); |
| void dom_namednodemap_unref(struct dom_namednodemap *map); |
| dom_exception dom_namednodemap_get_length(struct dom_namednodemap *map, |
| uint32_t *length); |
| dom_exception _dom_namednodemap_get_named_item(struct dom_namednodemap *map, |
| dom_string *name, struct dom_node **node); |
| #define dom_namednodemap_get_named_item(m, n, r) \ |
| _dom_namednodemap_get_named_item((dom_namednodemap *) (m), \ |
| (n), (dom_node **) (r)) |
| dom_exception _dom_namednodemap_set_named_item(struct dom_namednodemap *map, |
| struct dom_node *arg, struct dom_node **node); |
| #define dom_namednodemap_set_named_item(m, a, n) \ |
| _dom_namednodemap_set_named_item((dom_namednodemap *) (m), \ |
| (dom_node *) (a), (dom_node **) (n)) |
| dom_exception _dom_namednodemap_remove_named_item( |
| struct dom_namednodemap *map, dom_string *name, |
| struct dom_node **node); |
| #define dom_namednodemap_remove_named_item(m, n, r) \ |
| _dom_namednodemap_remove_named_item((dom_namednodemap *) (m), \ |
| (n), (dom_node **) (r)) |
| dom_exception _dom_namednodemap_item(struct dom_namednodemap *map, |
| uint32_t index, struct dom_node **node); |
| #define dom_namednodemap_item(m, i, n) _dom_namednodemap_item( \ |
| (dom_namednodemap *) (m), (uint32_t) (i), \ |
| (dom_node **) (n)) |
| dom_exception _dom_namednodemap_get_named_item_ns( |
| struct dom_namednodemap *map, dom_string *namespace, |
| dom_string *localname, struct dom_node **node); |
| #define dom_namednodemap_get_named_item_ns(m, n, l, r) \ |
| _dom_namednodemap_get_named_item_ns((dom_namednodemap *) (m), \ |
| (n), (l), (dom_node **) (r)) |
| dom_exception _dom_namednodemap_set_named_item_ns( |
| struct dom_namednodemap *map, struct dom_node *arg, |
| struct dom_node **node); |
| #define dom_namednodemap_set_named_item_ns(m, a, n) \ |
| _dom_namednodemap_set_named_item_ns((dom_namednodemap *) (m), \ |
| (dom_node *) (a), (dom_node **) (n)) |
| dom_exception _dom_namednodemap_remove_named_item_ns( |
| struct dom_namednodemap *map, dom_string *namespace, |
| dom_string *localname, struct dom_node **node); |
| #define dom_namednodemap_remove_named_item_ns(m, n, l, r) \ |
| _dom_namednodemap_remove_named_item_ns(\ |
| (dom_namednodemap *) (m), (n),(l), (dom_node **) (r)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/node.h |
|---|
| 0,0 → 1,569 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_node_h_ |
| #define dom_core_node_h_ |
| #include <inttypes.h> |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| #include <dom/events/event_target.h> |
| struct dom_document; |
| struct dom_nodelist; |
| struct dom_namednodemap; |
| struct dom_node; |
| /** |
| * Bits defining position of a node in a document relative to some other node |
| */ |
| typedef enum { |
| DOM_DOCUMENT_POSITION_DISCONNECTED = 0x01, |
| DOM_DOCUMENT_POSITION_PRECEDING = 0x02, |
| DOM_DOCUMENT_POSITION_FOLLOWING = 0x04, |
| DOM_DOCUMENT_POSITION_CONTAINS = 0x08, |
| DOM_DOCUMENT_POSITION_CONTAINED_BY = 0x10, |
| DOM_DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20 |
| } dom_document_position; |
| /** |
| * Type of node operation being notified to user_data_handler |
| */ |
| typedef enum { |
| DOM_NODE_CLONED = 1, |
| DOM_NODE_IMPORTED = 2, |
| DOM_NODE_DELETED = 3, |
| DOM_NODE_RENAMED = 4, |
| DOM_NODE_ADOPTED = 5 |
| } dom_node_operation; |
| /** |
| * Type of handler function for user data registered on a DOM node |
| */ |
| typedef void (*dom_user_data_handler)(dom_node_operation operation, |
| dom_string *key, void *data, struct dom_node *src, |
| struct dom_node *dst); |
| /** |
| * Type of a DOM node |
| */ |
| typedef enum { |
| DOM_ELEMENT_NODE = 1, |
| DOM_ATTRIBUTE_NODE = 2, |
| DOM_TEXT_NODE = 3, |
| DOM_CDATA_SECTION_NODE = 4, |
| DOM_ENTITY_REFERENCE_NODE = 5, |
| DOM_ENTITY_NODE = 6, |
| DOM_PROCESSING_INSTRUCTION_NODE = 7, |
| DOM_COMMENT_NODE = 8, |
| DOM_DOCUMENT_NODE = 9, |
| DOM_DOCUMENT_TYPE_NODE = 10, |
| DOM_DOCUMENT_FRAGMENT_NODE = 11, |
| DOM_NOTATION_NODE = 12, |
| /* And a count of the number of node types */ |
| DOM_NODE_TYPE_COUNT = DOM_NOTATION_NODE |
| } dom_node_type; |
| typedef struct dom_node_internal dom_node_internal; |
| /** |
| * DOM node type |
| */ |
| typedef struct dom_node { |
| void *vtable; |
| uint32_t refcnt; |
| } dom_node; |
| /* DOM node vtable */ |
| typedef struct dom_node_vtable { |
| dom_event_target_vtable base; |
| /* pre-destruction hook */ |
| dom_exception (*dom_node_try_destroy)(dom_node_internal *node); |
| /* The DOM level 3 node's oprations */ |
| dom_exception (*dom_node_get_node_name)(dom_node_internal *node, |
| dom_string **result); |
| dom_exception (*dom_node_get_node_value)(dom_node_internal *node, |
| dom_string **result); |
| dom_exception (*dom_node_set_node_value)(dom_node_internal *node, |
| dom_string *value); |
| dom_exception (*dom_node_get_node_type)(dom_node_internal *node, |
| dom_node_type *result); |
| dom_exception (*dom_node_get_parent_node)(dom_node_internal *node, |
| dom_node_internal **result); |
| dom_exception (*dom_node_get_child_nodes)(dom_node_internal *node, |
| struct dom_nodelist **result); |
| dom_exception (*dom_node_get_first_child)(dom_node_internal *node, |
| dom_node_internal **result); |
| dom_exception (*dom_node_get_last_child)(dom_node_internal *node, |
| dom_node_internal **result); |
| dom_exception (*dom_node_get_previous_sibling)(dom_node_internal *node, |
| dom_node_internal **result); |
| dom_exception (*dom_node_get_next_sibling)(dom_node_internal *node, |
| dom_node_internal **result); |
| dom_exception (*dom_node_get_attributes)(dom_node_internal *node, |
| struct dom_namednodemap **result); |
| dom_exception (*dom_node_get_owner_document)(dom_node_internal *node, |
| struct dom_document **result); |
| dom_exception (*dom_node_insert_before)(dom_node_internal *node, |
| dom_node_internal *new_child, |
| dom_node_internal *ref_child, |
| dom_node_internal **result); |
| dom_exception (*dom_node_replace_child)(dom_node_internal *node, |
| dom_node_internal *new_child, |
| dom_node_internal *old_child, |
| dom_node_internal **result); |
| dom_exception (*dom_node_remove_child)(dom_node_internal *node, |
| dom_node_internal *old_child, |
| dom_node_internal **result); |
| dom_exception (*dom_node_append_child)(dom_node_internal *node, |
| dom_node_internal *new_child, |
| dom_node_internal **result); |
| dom_exception (*dom_node_has_child_nodes)(dom_node_internal *node, |
| bool *result); |
| dom_exception (*dom_node_clone_node)(dom_node_internal *node, bool deep, |
| dom_node_internal **result); |
| dom_exception (*dom_node_normalize)(dom_node_internal *node); |
| dom_exception (*dom_node_is_supported)(dom_node_internal *node, |
| dom_string *feature, dom_string *version, |
| bool *result); |
| dom_exception (*dom_node_get_namespace)(dom_node_internal *node, |
| dom_string **result); |
| dom_exception (*dom_node_get_prefix)(dom_node_internal *node, |
| dom_string **result); |
| dom_exception (*dom_node_set_prefix)(dom_node_internal *node, |
| dom_string *prefix); |
| dom_exception (*dom_node_get_local_name)(dom_node_internal *node, |
| dom_string **result); |
| dom_exception (*dom_node_has_attributes)(dom_node_internal *node, |
| bool *result); |
| dom_exception (*dom_node_get_base)(dom_node_internal *node, |
| dom_string **result); |
| dom_exception (*dom_node_compare_document_position)( |
| dom_node_internal *node, dom_node_internal *other, |
| uint16_t *result); |
| dom_exception (*dom_node_get_text_content)(dom_node_internal *node, |
| dom_string **result); |
| dom_exception (*dom_node_set_text_content)(dom_node_internal *node, |
| dom_string *content); |
| dom_exception (*dom_node_is_same)(dom_node_internal *node, |
| dom_node_internal *other, bool *result); |
| dom_exception (*dom_node_lookup_prefix)(dom_node_internal *node, |
| dom_string *namespace, |
| dom_string **result); |
| dom_exception (*dom_node_is_default_namespace)(dom_node_internal *node, |
| dom_string *namespace, bool *result); |
| dom_exception (*dom_node_lookup_namespace)(dom_node_internal *node, |
| dom_string *prefix, dom_string **result); |
| dom_exception (*dom_node_is_equal)(dom_node_internal *node, |
| dom_node_internal *other, bool *result); |
| dom_exception (*dom_node_get_feature)(dom_node_internal *node, |
| dom_string *feature, dom_string *version, |
| void **result); |
| dom_exception (*dom_node_set_user_data)(dom_node_internal *node, |
| dom_string *key, void *data, |
| dom_user_data_handler handler, void **result); |
| dom_exception (*dom_node_get_user_data)(dom_node_internal *node, |
| dom_string *key, void **result); |
| } dom_node_vtable; |
| /* The ref/unref methods define */ |
| static inline dom_node *dom_node_ref(dom_node *node) |
| { |
| if (node != NULL) |
| node->refcnt++; |
| return node; |
| } |
| #define dom_node_ref(n) dom_node_ref((dom_node *) (n)) |
| static inline dom_exception dom_node_try_destroy(dom_node *node) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_try_destroy( |
| (dom_node_internal *) node); |
| } |
| #define dom_node_try_destroy(n) dom_node_try_destroy((dom_node *) (n)) |
| static inline void dom_node_unref(dom_node *node) |
| { |
| if (node != NULL) { |
| if (--node->refcnt == 0) |
| dom_node_try_destroy(node); |
| } |
| } |
| #define dom_node_unref(n) dom_node_unref((dom_node *) (n)) |
| static inline dom_exception dom_node_get_node_name(struct dom_node *node, |
| dom_string **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_node_name( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_node_name(n, r) dom_node_get_node_name((dom_node *) (n), (r)) |
| static inline dom_exception dom_node_get_node_value(struct dom_node *node, |
| dom_string **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_node_value( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_node_value(n, r) dom_node_get_node_value( \ |
| (dom_node *) (n), (r)) |
| static inline dom_exception dom_node_set_node_value(struct dom_node *node, |
| dom_string *value) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_set_node_value( |
| (dom_node_internal *) node, value); |
| } |
| #define dom_node_set_node_value(n, v) dom_node_set_node_value( \ |
| (dom_node *) (n), (v)) |
| static inline dom_exception dom_node_get_node_type(struct dom_node *node, |
| dom_node_type *result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_node_type( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_node_type(n, r) dom_node_get_node_type( \ |
| (dom_node *) (n), (dom_node_type *) (r)) |
| static inline dom_exception dom_node_get_parent_node(struct dom_node *node, |
| dom_node **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_parent_node( |
| (dom_node_internal *) node, |
| (dom_node_internal **) result); |
| } |
| #define dom_node_get_parent_node(n, r) dom_node_get_parent_node( \ |
| (dom_node *) (n), (dom_node **) (r)) |
| static inline dom_exception dom_node_get_child_nodes(struct dom_node *node, |
| struct dom_nodelist **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_child_nodes( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_child_nodes(n, r) dom_node_get_child_nodes( \ |
| (dom_node *) (n), (struct dom_nodelist **) (r)) |
| static inline dom_exception dom_node_get_first_child(struct dom_node *node, |
| dom_node **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_first_child( |
| (dom_node_internal *) node, |
| (dom_node_internal **) result); |
| } |
| #define dom_node_get_first_child(n, r) dom_node_get_first_child( \ |
| (dom_node *) (n), (dom_node **) (r)) |
| static inline dom_exception dom_node_get_last_child(struct dom_node *node, |
| dom_node **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_last_child( |
| (dom_node_internal *) node, |
| (dom_node_internal **) result); |
| } |
| #define dom_node_get_last_child(n, r) dom_node_get_last_child( \ |
| (dom_node *) (n), (dom_node **) (r)) |
| static inline dom_exception dom_node_get_previous_sibling( |
| struct dom_node *node, dom_node **result) |
| { |
| return ((dom_node_vtable *) node->vtable)-> |
| dom_node_get_previous_sibling( |
| (dom_node_internal *) node, |
| (dom_node_internal **) result); |
| } |
| #define dom_node_get_previous_sibling(n, r) dom_node_get_previous_sibling( \ |
| (dom_node *) (n), (dom_node **) (r)) |
| static inline dom_exception dom_node_get_next_sibling(struct dom_node *node, |
| dom_node **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_next_sibling( |
| (dom_node_internal *) node, |
| (dom_node_internal **) result); |
| } |
| #define dom_node_get_next_sibling(n, r) dom_node_get_next_sibling( \ |
| (dom_node *) (n), (dom_node **) (r)) |
| static inline dom_exception dom_node_get_attributes(struct dom_node *node, |
| struct dom_namednodemap **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_attributes( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_attributes(n, r) dom_node_get_attributes( \ |
| (dom_node *) (n), (struct dom_namednodemap **) (r)) |
| static inline dom_exception dom_node_get_owner_document(struct dom_node *node, |
| struct dom_document **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_owner_document( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_owner_document(n, r) dom_node_get_owner_document( \ |
| (dom_node *) (n), (struct dom_document **) (r)) |
| static inline dom_exception dom_node_insert_before(struct dom_node *node, |
| struct dom_node *new_child, struct dom_node *ref_child, |
| struct dom_node **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_insert_before( |
| (dom_node_internal *) node, |
| (dom_node_internal *) new_child, |
| (dom_node_internal *) ref_child, |
| (dom_node_internal **) result); |
| } |
| #define dom_node_insert_before(n, nn, ref, ret) dom_node_insert_before( \ |
| (dom_node *) (n), (dom_node *) (nn), (dom_node *) (ref),\ |
| (dom_node **) (ret)) |
| static inline dom_exception dom_node_replace_child(struct dom_node *node, |
| struct dom_node *new_child, struct dom_node *old_child, |
| struct dom_node **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_replace_child( |
| (dom_node_internal *) node, |
| (dom_node_internal *) new_child, |
| (dom_node_internal *) old_child, |
| (dom_node_internal **) result); |
| } |
| #define dom_node_replace_child(n, nn, old, ret) dom_node_replace_child( \ |
| (dom_node *) (n), (dom_node *) (nn), (dom_node *) (old),\ |
| (dom_node **) (ret)) |
| static inline dom_exception dom_node_remove_child(struct dom_node *node, |
| struct dom_node *old_child, |
| struct dom_node **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_remove_child( |
| (dom_node_internal *) node, |
| (dom_node_internal *) old_child, |
| (dom_node_internal **) result); |
| } |
| #define dom_node_remove_child(n, old, ret) dom_node_remove_child( \ |
| (dom_node *) (n), (dom_node *) (old), (dom_node **) (ret)) |
| static inline dom_exception dom_node_append_child(struct dom_node *node, |
| struct dom_node *new_child, |
| struct dom_node **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_append_child( |
| (dom_node_internal *) node, |
| (dom_node_internal *) new_child, |
| (dom_node_internal **) result); |
| } |
| #define dom_node_append_child(n, nn, ret) dom_node_append_child( \ |
| (dom_node *) (n), (dom_node *) (nn), (dom_node **) (ret)) |
| static inline dom_exception dom_node_has_child_nodes(struct dom_node *node, |
| bool *result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_has_child_nodes( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_has_child_nodes(n, r) dom_node_has_child_nodes( \ |
| (dom_node *) (n), (bool *) (r)) |
| static inline dom_exception dom_node_clone_node(struct dom_node *node, |
| bool deep, struct dom_node **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_clone_node( |
| (dom_node_internal *) node, deep, |
| (dom_node_internal **) result); |
| } |
| #define dom_node_clone_node(n, d, r) dom_node_clone_node((dom_node *) (n), \ |
| (bool) (d), (dom_node **) (r)) |
| static inline dom_exception dom_node_normalize(struct dom_node *node) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_normalize( |
| (dom_node_internal *) node); |
| } |
| #define dom_node_normalize(n) dom_node_normalize((dom_node *) (n)) |
| static inline dom_exception dom_node_is_supported(struct dom_node *node, |
| dom_string *feature, dom_string *version, |
| bool *result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_is_supported( |
| (dom_node_internal *) node, feature, |
| version, result); |
| } |
| #define dom_node_is_supported(n, f, v, r) dom_node_is_supported( \ |
| (dom_node *) (n), (f), (v), (bool *) (r)) |
| static inline dom_exception dom_node_get_namespace(struct dom_node *node, |
| dom_string **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_namespace( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_namespace(n, r) dom_node_get_namespace((dom_node *) (n), (r)) |
| static inline dom_exception dom_node_get_prefix(struct dom_node *node, |
| dom_string **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_prefix( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_prefix(n, r) dom_node_get_prefix((dom_node *) (n), (r)) |
| static inline dom_exception dom_node_set_prefix(struct dom_node *node, |
| dom_string *prefix) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_set_prefix( |
| (dom_node_internal *) node, prefix); |
| } |
| #define dom_node_set_prefix(n, p) dom_node_set_prefix((dom_node *) (n), (p)) |
| static inline dom_exception dom_node_get_local_name(struct dom_node *node, |
| dom_string **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_local_name( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_local_name(n, r) dom_node_get_local_name((dom_node *) (n), (r)) |
| static inline dom_exception dom_node_has_attributes(struct dom_node *node, |
| bool *result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_has_attributes( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_has_attributes(n, r) dom_node_has_attributes( \ |
| (dom_node *) (n), (bool *) (r)) |
| static inline dom_exception dom_node_get_base(struct dom_node *node, |
| dom_string **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_base( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_base(n, r) dom_node_get_base((dom_node *) (n), (r)) |
| static inline dom_exception dom_node_compare_document_position( |
| struct dom_node *node, struct dom_node *other, |
| uint16_t *result) |
| { |
| return ((dom_node_vtable *) node->vtable)-> |
| dom_node_compare_document_position( |
| (dom_node_internal *) node, |
| (dom_node_internal *) other, result); |
| } |
| #define dom_node_compare_document_position(n, o, r) \ |
| dom_node_compare_document_position((dom_node *) (n), \ |
| (dom_node *) (o), (uint16_t *) (r)) |
| static inline dom_exception dom_node_get_text_content(struct dom_node *node, |
| dom_string **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_text_content( |
| (dom_node_internal *) node, result); |
| } |
| #define dom_node_get_text_content(n, r) dom_node_get_text_content( \ |
| (dom_node *) (n), (r)) |
| static inline dom_exception dom_node_set_text_content(struct dom_node *node, |
| dom_string *content) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_set_text_content( |
| (dom_node_internal *) node, content); |
| } |
| #define dom_node_set_text_content(n, c) dom_node_set_text_content( \ |
| (dom_node *) (n), (c)) |
| static inline dom_exception dom_node_is_same(struct dom_node *node, |
| struct dom_node *other, bool *result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_is_same( |
| (dom_node_internal *) node, |
| (dom_node_internal *) other, |
| result); |
| } |
| #define dom_node_is_same(n, o, r) dom_node_is_same((dom_node *) (n), \ |
| (dom_node *) (o), (bool *) (r)) |
| static inline dom_exception dom_node_lookup_prefix(struct dom_node *node, |
| dom_string *namespace, dom_string **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_lookup_prefix( |
| (dom_node_internal *) node, namespace, result); |
| } |
| #define dom_node_lookup_prefix(n, ns, r) dom_node_lookup_prefix( \ |
| (dom_node *) (n), (ns), (r)) |
| static inline dom_exception dom_node_is_default_namespace( |
| struct dom_node *node, dom_string *namespace, |
| bool *result) |
| { |
| return ((dom_node_vtable *) node->vtable)-> |
| dom_node_is_default_namespace( |
| (dom_node_internal *) node, namespace, result); |
| } |
| #define dom_node_is_default_namespace(n, ns, r) dom_node_is_default_namespace(\ |
| (dom_node *) (n), (ns), (bool *) (r)) |
| static inline dom_exception dom_node_lookup_namespace(struct dom_node *node, |
| dom_string *prefix, dom_string **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_lookup_namespace( |
| (dom_node_internal *) node, prefix, result); |
| } |
| #define dom_node_lookup_namespace(n, p, r) dom_node_lookup_namespace( \ |
| (dom_node *) (n), (p), (r)) |
| static inline dom_exception dom_node_is_equal(struct dom_node *node, |
| struct dom_node *other, bool *result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_is_equal( |
| (dom_node_internal *) node, |
| (dom_node_internal *) other, |
| result); |
| } |
| #define dom_node_is_equal(n, o, r) dom_node_is_equal((dom_node *) (n), \ |
| (dom_node *) (o), (bool *) (r)) |
| static inline dom_exception dom_node_get_feature(struct dom_node *node, |
| dom_string *feature, dom_string *version, |
| void **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_feature( |
| (dom_node_internal *) node, feature, version, result); |
| } |
| #define dom_node_get_feature(n, f, v, r) dom_node_get_feature( \ |
| (dom_node *) (n), (f), (v), (void **) (r)) |
| static inline dom_exception dom_node_set_user_data(struct dom_node *node, |
| dom_string *key, void *data, |
| dom_user_data_handler handler, void **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_set_user_data( |
| (dom_node_internal *) node, key, data, handler, |
| result); |
| } |
| #define dom_node_set_user_data(n, k, d, h, r) dom_node_set_user_data( \ |
| (dom_node *) (n), (k), (void *) (d), \ |
| (dom_user_data_handler) h, (void **) (r)) |
| static inline dom_exception dom_node_get_user_data(struct dom_node *node, |
| dom_string *key, void **result) |
| { |
| return ((dom_node_vtable *) node->vtable)->dom_node_get_user_data( |
| (dom_node_internal *) node, key, result); |
| } |
| #define dom_node_get_user_data(n, k, r) dom_node_get_user_data( \ |
| (dom_node *) (n), (k), (void **) (r)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/nodelist.h |
|---|
| 0,0 → 1,28 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_nodelist_h_ |
| #define dom_core_nodelist_h_ |
| #include <dom/core/exceptions.h> |
| struct dom_node; |
| typedef struct dom_nodelist dom_nodelist; |
| void dom_nodelist_ref(struct dom_nodelist *list); |
| void dom_nodelist_unref(struct dom_nodelist *list); |
| dom_exception dom_nodelist_get_length(struct dom_nodelist *list, |
| uint32_t *length); |
| dom_exception _dom_nodelist_item(struct dom_nodelist *list, |
| uint32_t index, struct dom_node **node); |
| #define dom_nodelist_item(l, i, n) _dom_nodelist_item((dom_nodelist *) (l), \ |
| (uint32_t) (i), (dom_node **) (n)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/pi.h |
|---|
| 0,0 → 1,13 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_processinginstruction_h_ |
| #define dom_core_processinginstruction_h_ |
| typedef struct dom_processing_instruction dom_processing_instruction; |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/string.h |
|---|
| 0,0 → 1,116 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_string_h_ |
| #define dom_string_h_ |
| #include <inttypes.h> |
| #include <stddef.h> |
| #include <libwapcaplet/libwapcaplet.h> |
| #include <dom/functypes.h> |
| #include <dom/core/exceptions.h> |
| typedef struct dom_string dom_string; |
| extern struct dom_string { |
| uint32_t refcnt; |
| } _ALIGNED; |
| /* Claim a reference on a DOM string */ |
| static inline dom_string *dom_string_ref(dom_string *str) |
| { |
| if (str != NULL) |
| str->refcnt++; |
| return str; |
| } |
| /* Destroy a DOM string */ |
| void dom_string_destroy(dom_string *str); |
| /* Release a reference on a DOM string */ |
| static inline void dom_string_unref(dom_string *str) |
| { |
| if ((str != NULL) && (--(str->refcnt) == 0)) { |
| dom_string_destroy(str); |
| } |
| } |
| /* Create a DOM string from a string of characters */ |
| dom_exception dom_string_create(const uint8_t *ptr, size_t len, |
| dom_string **str); |
| dom_exception dom_string_create_interned(const uint8_t *ptr, size_t len, |
| dom_string **str); |
| /* Obtain an interned representation of a dom string */ |
| dom_exception dom_string_intern(dom_string *str, |
| struct lwc_string_s **lwcstr); |
| /* Case sensitively compare two DOM strings */ |
| bool dom_string_isequal(const dom_string *s1, const dom_string *s2); |
| /* Case insensitively compare two DOM strings */ |
| bool dom_string_caseless_isequal(const dom_string *s1, const dom_string *s2); |
| /* Case sensitively compare DOM string and lwc_string */ |
| bool dom_string_lwc_isequal(const dom_string *s1, lwc_string *s2); |
| /* Case insensitively compare DOM string and lwc_string */ |
| bool dom_string_caseless_lwc_isequal(const dom_string *s1, lwc_string *s2); |
| /* Get the index of the first occurrence of a character in a dom string */ |
| uint32_t dom_string_index(dom_string *str, uint32_t chr); |
| /* Get the index of the last occurrence of a character in a dom string */ |
| uint32_t dom_string_rindex(dom_string *str, uint32_t chr); |
| /* Get the length, in characters, of a dom string */ |
| uint32_t dom_string_length(dom_string *str); |
| /** |
| * Get the raw character data of the dom_string. |
| * @note: This function is just provided for the convenience of accessing the |
| * raw C string character, no change on the result string is allowed. |
| */ |
| const char *dom_string_data(const dom_string *str); |
| /* Get the byte length of this dom_string */ |
| size_t dom_string_byte_length(const dom_string *str); |
| /* Get the UCS-4 character at position index, the index should be in |
| * [0, length), and length can be get by calling dom_string_length |
| */ |
| dom_exception dom_string_at(dom_string *str, uint32_t index, |
| uint32_t *ch); |
| /* Concatenate two dom strings */ |
| dom_exception dom_string_concat(dom_string *s1, dom_string *s2, |
| dom_string **result); |
| /* Extract a substring from a dom string */ |
| dom_exception dom_string_substr(dom_string *str, |
| uint32_t i1, uint32_t i2, dom_string **result); |
| /* Insert data into a dom string at the given location */ |
| dom_exception dom_string_insert(dom_string *target, |
| dom_string *source, uint32_t offset, |
| dom_string **result); |
| /* Replace a section of a dom string */ |
| dom_exception dom_string_replace(dom_string *target, |
| dom_string *source, uint32_t i1, uint32_t i2, |
| dom_string **result); |
| /* Generate an uppercase version of the given string */ |
| dom_exception dom_string_toupper(dom_string *source, bool ascii_only, |
| dom_string **upper); |
| /* Generate an lowercase version of the given string */ |
| dom_exception dom_string_tolower(dom_string *source, bool ascii_only, |
| dom_string **lower); |
| /* Calculate a hash value from a dom string */ |
| uint32_t dom_string_hash(dom_string *str); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/text.h |
|---|
| 0,0 → 1,70 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_core_text_h_ |
| #define dom_core_text_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/characterdata.h> |
| struct dom_characterdata; |
| typedef struct dom_text dom_text; |
| typedef struct dom_text_vtable { |
| struct dom_characterdata_vtable base; |
| dom_exception (*dom_text_split_text)(struct dom_text *text, |
| uint32_t offset, struct dom_text **result); |
| dom_exception (*dom_text_get_is_element_content_whitespace)( |
| struct dom_text *text, bool *result); |
| dom_exception (*dom_text_get_whole_text)(struct dom_text *text, |
| dom_string **result); |
| dom_exception (*dom_text_replace_whole_text)(struct dom_text *text, |
| dom_string *content, struct dom_text **result); |
| } dom_text_vtable; |
| static inline dom_exception dom_text_split_text(struct dom_text *text, |
| uint32_t offset, struct dom_text **result) |
| { |
| return ((dom_text_vtable *) ((dom_node *) text)->vtable)-> |
| dom_text_split_text(text, offset, result); |
| } |
| #define dom_text_split_text(t, o, r) dom_text_split_text((dom_text *) (t), \ |
| (uint32_t) (o), (dom_text **) (r)) |
| static inline dom_exception dom_text_get_is_element_content_whitespace( |
| struct dom_text *text, bool *result) |
| { |
| return ((dom_text_vtable *) ((dom_node *) text)->vtable)-> |
| dom_text_get_is_element_content_whitespace(text, |
| result); |
| } |
| #define dom_text_get_is_element_content_whitespace(t, r) \ |
| dom_text_get_is_element_content_whitespace((dom_text *) (t), \ |
| (bool *) (r)) |
| static inline dom_exception dom_text_get_whole_text(struct dom_text *text, |
| dom_string **result) |
| { |
| return ((dom_text_vtable *) ((dom_node *) text)->vtable)-> |
| dom_text_get_whole_text(text, result); |
| } |
| #define dom_text_get_whole_text(t, r) dom_text_get_whole_text((dom_text *) (t), (r)) |
| static inline dom_exception dom_text_replace_whole_text(struct dom_text *text, |
| dom_string *content, struct dom_text **result) |
| { |
| return ((dom_text_vtable *) ((dom_node *) text)->vtable)-> |
| dom_text_replace_whole_text(text, content, result); |
| } |
| #define dom_text_replace_whole_text(t, c, r) dom_text_replace_whole_text( \ |
| (dom_text *) (t), (c), (dom_text **) (r)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/core/typeinfo.h |
|---|
| 0,0 → 1,45 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_core_typeinfo_h_ |
| #define dom_core_typeinfo_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| typedef struct dom_type_info dom_type_info; |
| typedef enum { |
| DOM_TYPE_INFO_DERIVATION_RESTRICTION = 0x00000001, |
| DOM_TYPE_INFO_DERIVATION_EXTENSION = 0x00000002, |
| DOM_TYPE_INFO_DERIVATION_UNION = 0x00000004, |
| DOM_TYPE_INFO_DERIVATION_LIST = 0x00000008 |
| } dom_type_info_derivation_method; |
| dom_exception _dom_type_info_get_type_name(dom_type_info *ti, |
| dom_string **ret); |
| #define dom_type_info_get_type_name(t, r) _dom_type_info_get_type_name( \ |
| (dom_type_info *) (t), (r)) |
| dom_exception _dom_type_info_get_type_namespace(dom_type_info *ti, |
| dom_string **ret); |
| #define dom_type_info_get_type_namespace(t, r) \ |
| _dom_type_info_get_type_namespace((dom_type_info *) (t), (r)) |
| dom_exception _dom_type_info_is_derived(dom_type_info *ti, |
| dom_string *namespace, dom_string *name, |
| dom_type_info_derivation_method method, bool *ret); |
| #define dom_type_info_is_derived(t, s, n, m, r) _dom_type_info_is_derived(\ |
| (dom_type_info *) (t), (s), (n), \ |
| (dom_type_info_derivation_method) (m), (bool *) (r)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/dom.h |
|---|
| 0,0 → 1,75 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| /** \file |
| * This is the top-level header file for libdom. The intention of this is |
| * to allow client applications to simply include this file and get access |
| * to all the libdom API. |
| */ |
| #ifndef dom_dom_h_ |
| #define dom_dom_h_ |
| /* Base library headers */ |
| #include <dom/functypes.h> |
| /* DOM core headers */ |
| #include <dom/core/attr.h> |
| #include <dom/core/characterdata.h> |
| #include <dom/core/document.h> |
| #include <dom/core/document_type.h> |
| #include <dom/core/element.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/implementation.h> |
| #include <dom/core/namednodemap.h> |
| #include <dom/core/node.h> |
| #include <dom/core/cdatasection.h> |
| #include <dom/core/doc_fragment.h> |
| #include <dom/core/entity_ref.h> |
| #include <dom/core/nodelist.h> |
| #include <dom/core/string.h> |
| #include <dom/core/text.h> |
| #include <dom/core/pi.h> |
| #include <dom/core/typeinfo.h> |
| #include <dom/core/comment.h> |
| /* DOM HTML headers */ |
| #include <dom/html/html_collection.h> |
| #include <dom/html/html_document.h> |
| #include <dom/html/html_element.h> |
| #include <dom/html/html_html_element.h> |
| #include <dom/html/html_head_element.h> |
| #include <dom/html/html_link_element.h> |
| #include <dom/html/html_title_element.h> |
| #include <dom/html/html_body_element.h> |
| #include <dom/html/html_meta_element.h> |
| #include <dom/html/html_form_element.h> |
| #include <dom/html/html_input_element.h> |
| #include <dom/html/html_button_element.h> |
| #include <dom/html/html_text_area_element.h> |
| #include <dom/html/html_opt_group_element.h> |
| #include <dom/html/html_option_element.h> |
| #include <dom/html/html_select_element.h> |
| /* DOM Events header */ |
| #include <dom/events/events.h> |
| typedef enum dom_namespace { |
| DOM_NAMESPACE_NULL = 0, |
| DOM_NAMESPACE_HTML = 1, |
| DOM_NAMESPACE_MATHML = 2, |
| DOM_NAMESPACE_SVG = 3, |
| DOM_NAMESPACE_XLINK = 4, |
| DOM_NAMESPACE_XML = 5, |
| DOM_NAMESPACE_XMLNS = 6, |
| DOM_NAMESPACE_COUNT = 7 |
| } dom_namespace; |
| extern dom_string *dom_namespaces[DOM_NAMESPACE_COUNT]; |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/custom_event.h |
|---|
| 0,0 → 1,31 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_custom_event_h_ |
| #define dom_events_custom_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| typedef struct dom_custom_event dom_custom_event; |
| dom_exception _dom_custom_event_get_detail(dom_custom_event *evt, |
| void **detail); |
| #define dom_custom_event_get_detail(e, d) \ |
| _dom_custom_event_get_detail((dom_custom_event *) (e),\ |
| (void **) (d)) |
| dom_exception _dom_custom_event_init_ns(dom_custom_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, void *detail); |
| #define dom_custom_event_init_ns(e, n, t, b, c, d) \ |
| _dom_custom_event_init_ns((dom_custom_event *) (e), \ |
| (dom_string *) (n), (dom_string *) (t), \ |
| (bool) (b), (bool) (c), (void *) (d)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/document_event.h |
|---|
| 0,0 → 1,100 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_document_event_h_ |
| #define dom_events_document_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_event; |
| struct dom_document; |
| typedef struct dom_document dom_document_event; |
| /** |
| * The callback function which is used to process the default action of any |
| * event. |
| * |
| * As ::dom_default_action_phase defines, we have three points in our |
| * implementation where these kinds of callbacks get invoked. |
| * |
| * When the implementation start to dispatch certain event, it firstly invoke |
| * the following callback, which should process the event before the normal |
| * event flow. |
| * |
| * Take a MousePressed event on a check box object as example: |
| * 1. The 'pressed' event is generated by OS and catched by our UI code; |
| * 2. The UI code dispatch the event to DOM; |
| * 3. DOM trys to dispatch the event as what the spec said; |
| * 4. Before the real event flow happens, DOM get the |
| * dom_default_action_callback function from the |
| * dom_events_default_action_fetcher with param |
| * DOM_DEFAULT_ACTION_STARTED, and then call it; |
| * 5. The callback function invoke some System-denpendent API to make the |
| * checkbox checked and then return; |
| * 6. Normal event flow goes on. |
| * 7. When the implementation reach the end of the event flow, it check whether |
| * the event's default action is prevented, if it is, then go to step 8, |
| * else go to step 9. |
| * 8. The event's default action get prevented, DOM get the |
| * dom_default_action_callback function from the |
| * dom_events_default_action_fetcher with param |
| * DOM_DEFAULT_ACTION_PREVENTED, and then call it. |
| * 8. The event's default action does not get prevented, DOM get the |
| * dom_default_action_callback function from the |
| * dom_events_default_action_fetcher with param |
| * DOM_DEFAULT_ACTION_END, and then call it. |
| * |
| * @note: the point here is that we want the UI related stuff to be done |
| * within the default action code. The DOM only take care of the content tree |
| * and the event flow itself. |
| */ |
| typedef void (*dom_default_action_callback)(struct dom_event *evt, void *pw); |
| /** |
| * The default action phase |
| * |
| * @note: we define the following three values to fetch three different types |
| * of dom_default_action_callback function and their private data. |
| */ |
| typedef enum { |
| DOM_DEFAULT_ACTION_STARTED = 0, |
| DOM_DEFAULT_ACTION_PREVENTED, |
| DOM_DEFAULT_ACTION_END |
| } dom_default_action_phase; |
| /** |
| * The default action fetcher |
| * |
| * \param type The type of the event |
| * \param phase The phase of the default action callback |
| * \param pw The return private data of the callback function |
| * \return a callback function, NULL if there is none. |
| */ |
| typedef dom_default_action_callback (*dom_events_default_action_fetcher) |
| (dom_string *type, dom_default_action_phase phase, |
| void **pw); |
| dom_exception _dom_document_event_create_event(dom_document_event *de, |
| dom_string *type, struct dom_event **evt); |
| #define dom_document_event_create_event(d, t, e) \ |
| _dom_document_event_create_event((dom_document_event *) (d), \ |
| (dom_string *) (t), (struct dom_event **) (e)) |
| dom_exception _dom_document_event_can_dispatch(dom_document_event *de, |
| dom_string *namespace, dom_string *type, |
| bool* can); |
| #define dom_document_event_can_dispatch(d, n, t, c) \ |
| _dom_document_event_can_dispatch((dom_document_event *) (d), \ |
| (dom_string *) (n), (dom_string *) (t),\ |
| (bool *) (c)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/event.h |
|---|
| 0,0 → 1,92 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_event_h_ |
| #define dom_events_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| #include <dom/events/event_target.h> |
| typedef enum { |
| DOM_CAPTURING_PHASE = 1, |
| DOM_AT_TARGET = 2, |
| DOM_BUBBLING_PHASE = 3 |
| } dom_event_flow_phase; |
| typedef struct dom_event dom_event; |
| /* The ref/unref methods define */ |
| void _dom_event_ref(dom_event *evt); |
| #define dom_event_ref(n) _dom_event_ref((dom_event *) (n)) |
| void _dom_event_unref(dom_event *evt); |
| #define dom_event_unref(n) _dom_event_unref((dom_event *) (n)) |
| dom_exception _dom_event_get_type(dom_event *evt, dom_string **type); |
| #define dom_event_get_type(e, t) _dom_event_get_type((dom_event *) (e), \ |
| (dom_string **) (t)) |
| dom_exception _dom_event_get_target(dom_event *evt, dom_event_target **target); |
| #define dom_event_get_target(e, t) _dom_event_get_target((dom_event *) (e), \ |
| (dom_event_target **) (t)) |
| dom_exception _dom_event_get_current_target(dom_event *evt, |
| dom_event_target **current); |
| #define dom_event_get_current_target(e, c) _dom_event_get_current_target(\ |
| (dom_event *) (e), (dom_event_target **) (c)) |
| dom_exception _dom_event_get_bubbles(dom_event *evt, bool *bubbles); |
| #define dom_event_get_bubbles(e, b) _dom_event_get_bubbles((dom_event *) (e), \ |
| (bool *) (b)) |
| dom_exception _dom_event_get_cancelable(dom_event *evt, bool *cancelable); |
| #define dom_event_get_cancelable(e, c) _dom_event_get_cancelable(\ |
| (dom_event *) (e), (bool *) (c)) |
| dom_exception _dom_event_get_timestamp(dom_event *evt, |
| unsigned int *timestamp); |
| #define dom_event_get_timestamp(e, t) _dom_event_get_timestamp(\ |
| (dom_event *) (e), (unsigned int *) (t)) |
| dom_exception _dom_event_stop_propagation(dom_event *evt); |
| #define dom_event_stop_propagation(e) _dom_event_stop_propagation(\ |
| (dom_event *) (e)) |
| dom_exception _dom_event_prevent_default(dom_event *evt); |
| #define dom_event_prevent_default(e) _dom_event_prevent_default(\ |
| (dom_event *) (e)) |
| dom_exception _dom_event_init(dom_event *evt, dom_string *type, |
| bool bubble, bool cancelable); |
| #define dom_event_init(e, t, b, c) _dom_event_init((dom_event *) (e), \ |
| (dom_string *) (t), (bool) (b), (bool) (c)) |
| dom_exception _dom_event_get_namespace(dom_event *evt, |
| dom_string **namespace); |
| #define dom_event_get_namespace(e, n) _dom_event_get_namespace(\ |
| (dom_event *) (e), (dom_string **) (n)) |
| dom_exception _dom_event_is_custom(dom_event *evt, bool *custom); |
| #define dom_event_is_custom(e, c) _dom_event_is_custom((dom_event *) (e), \ |
| (bool *) (c)) |
| dom_exception _dom_event_stop_immediate_propagation(dom_event *evt); |
| #define dom_event_stop_immediate_propagation(e) \ |
| _dom_event_stop_immediate_propagation((dom_event *) (e)) |
| dom_exception _dom_event_is_default_prevented(dom_event *evt, bool *prevented); |
| #define dom_event_is_default_prevented(e, p) \ |
| _dom_event_is_default_prevented((dom_event *) (e), (bool *) (p)) |
| dom_exception _dom_event_init_ns(dom_event *evt, dom_string *namespace, |
| dom_string *type, bool bubble, bool cancelable); |
| #define dom_event_init_ns(e, n, t, b, c) _dom_event_init_ns( \ |
| (dom_event *) (e), (dom_string *) (n), \ |
| (dom_string *) (t), (bool) (b), (bool) (c)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/event_listener.h |
|---|
| 0,0 → 1,27 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_event_listener_h_ |
| #define dom_events_event_listener_h_ |
| #include <dom/core/exceptions.h> |
| struct dom_document; |
| struct dom_event; |
| typedef void (*handle_event)(struct dom_event *evt, void *pw); |
| typedef struct dom_event_listener dom_event_listener; |
| dom_exception dom_event_listener_create(struct dom_document *doc, |
| handle_event handler, void *pw, dom_event_listener **listener); |
| void dom_event_listener_ref(dom_event_listener *listener); |
| void dom_event_listener_unref(dom_event_listener *listener); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/event_target.h |
|---|
| 0,0 → 1,111 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_event_target_h_ |
| #define dom_events_event_target_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_event_listener; |
| struct dom_event; |
| /* Event target is a mixin interface, thus has no concrete implementation. |
| * Subclasses must provide implementations of the event target methods. */ |
| typedef struct dom_event_target { |
| void *vtable; |
| } dom_event_target; |
| typedef struct dom_event_target_vtable { |
| dom_exception (*add_event_listener)( |
| dom_event_target *et, dom_string *type, |
| struct dom_event_listener *listener, |
| bool capture); |
| dom_exception (*remove_event_listener)( |
| dom_event_target *et, dom_string *type, |
| struct dom_event_listener *listener, |
| bool capture); |
| dom_exception (*dispatch_event)( |
| dom_event_target *et, |
| struct dom_event *evt, bool *success); |
| dom_exception (*add_event_listener_ns)( |
| dom_event_target *et, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, |
| bool capture); |
| dom_exception (*remove_event_listener_ns)( |
| dom_event_target *et, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, |
| bool capture); |
| } dom_event_target_vtable; |
| static inline dom_exception dom_event_target_add_event_listener( |
| dom_event_target *et, dom_string *type, |
| struct dom_event_listener *listener, bool capture) |
| { |
| return ((dom_event_target_vtable *) et->vtable)->add_event_listener( |
| et, type, listener, capture); |
| } |
| #define dom_event_target_add_event_listener(et, t, l, c) \ |
| dom_event_target_add_event_listener((dom_event_target *) (et),\ |
| (dom_string *) (t), (struct dom_event_listener *) (l), \ |
| (bool) (c)) |
| static inline dom_exception dom_event_target_remove_event_listener( |
| dom_event_target *et, dom_string *type, |
| struct dom_event_listener *listener, bool capture) |
| { |
| return ((dom_event_target_vtable *) et->vtable)->remove_event_listener( |
| et, type, listener, capture); |
| } |
| #define dom_event_target_remove_event_listener(et, t, l, c) \ |
| dom_event_target_remove_event_listener(\ |
| (dom_event_target *) (et), (dom_string *) (t),\ |
| (struct dom_event_listener *) (l), (bool) (c)) |
| static inline dom_exception dom_event_target_dispatch_event( |
| dom_event_target *et, struct dom_event *evt, bool *success) |
| { |
| return ((dom_event_target_vtable *) et->vtable)->dispatch_event( |
| et, evt, success); |
| } |
| #define dom_event_target_dispatch_event(et, e, s) \ |
| dom_event_target_dispatch_event((dom_event_target *) (et),\ |
| (struct dom_event *) (e), (bool *) (s)) |
| static inline dom_exception dom_event_target_add_event_listener_ns( |
| dom_event_target *et, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, bool capture) |
| { |
| return ((dom_event_target_vtable *) et->vtable)->add_event_listener_ns( |
| et, namespace, type, listener, capture); |
| } |
| #define dom_event_target_add_event_listener_ns(et, n, t, l, c) \ |
| dom_event_target_add_event_listener_ns(\ |
| (dom_event_target *) (et), (dom_string *) (n),\ |
| (dom_string *) (t), (struct dom_event_listener *) (l),\ |
| (bool) (c)) |
| static inline dom_exception dom_event_target_remove_event_listener_ns( |
| dom_event_target *et, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, bool capture) |
| { |
| return ((dom_event_target_vtable *) et->vtable)->remove_event_listener_ns( |
| et, namespace, type, listener, capture); |
| } |
| #define dom_event_target_remove_event_listener_ns(et, n, t, l, c) \ |
| dom_event_target_remove_event_listener_ns(\ |
| (dom_event_target *) (et), (dom_string *) (n),\ |
| (dom_string *) (t), (struct dom_event_listener *) (l),\ |
| (bool) (c)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/events.h |
|---|
| 0,0 → 1,25 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_h_ |
| #define dom_events_h_ |
| #include <dom/events/event.h> |
| #include <dom/events/ui_event.h> |
| #include <dom/events/custom_event.h> |
| #include <dom/events/mouse_event.h> |
| #include <dom/events/keyboard_event.h> |
| #include <dom/events/mouse_wheel_event.h> |
| #include <dom/events/mouse_multi_wheel_event.h> |
| #include <dom/events/mutation_event.h> |
| #include <dom/events/mutation_name_event.h> |
| #include <dom/events/text_event.h> |
| #include <dom/events/event_listener.h> |
| #include <dom/events/document_event.h> |
| #include <dom/events/event_target.h> |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/keyboard_event.h |
|---|
| 0,0 → 1,89 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_keyboard_event_h_ |
| #define dom_events_keyboard_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_abstract_view; |
| typedef struct dom_keyboard_event dom_keyboard_event; |
| typedef enum { |
| DOM_KEY_LOCATION_STANDARD = 0, |
| DOM_KEY_LOCATION_LEFT = 1, |
| DOM_KEY_LOCATION_RIGHT = 2, |
| DOM_KEY_LOCATION_NUMPAD = 3 |
| } dom_key_location; |
| dom_exception _dom_keyboard_event_get_key_identifier(dom_keyboard_event *evt, |
| dom_string **ident); |
| #define dom_keyboard_event_get_key_identifier(e, i) \ |
| _dom_keyboard_event_get_key_identifier( \ |
| (dom_keyboard_event *) (e), (dom_string **) (i)) |
| dom_exception _dom_keyboard_event_get_key_location(dom_keyboard_event *evt, |
| dom_key_location *loc); |
| #define dom_keyboard_event_get_key_location(e, l) \ |
| _dom_keyboard_event_get_key_location( \ |
| (dom_keyboard_event *) (e), (dom_key_location *) (l)) |
| dom_exception _dom_keyboard_event_get_ctrl_key(dom_keyboard_event *evt, |
| bool *key); |
| #define dom_keyboard_event_get_ctrl_key(e, k) _dom_keyboard_event_get_ctrl_key(\ |
| (dom_keyboard_event *) (e), (bool *) (k)) |
| dom_exception _dom_keyboard_event_get_shift_key(dom_keyboard_event *evt, |
| bool *key); |
| #define dom_keyboard_event_get_shift_key(e, k) \ |
| _dom_keyboard_event_get_shift_key((dom_keyboard_event *) (e), \ |
| (bool *) (k)) |
| dom_exception _dom_keyboard_event_get_alt_key(dom_keyboard_event *evt, |
| bool *key); |
| #define dom_keyboard_event_get_alt_key(e, k) _dom_keyboard_event_get_alt_key(\ |
| (dom_keyboard_event *) (e), (bool *) (k)) |
| dom_exception _dom_keyboard_event_get_meta_key(dom_keyboard_event *evt, |
| bool *key); |
| #define dom_keyboard_event_get_meta_key(e, k) _dom_keyboard_event_get_meta_key(\ |
| (dom_keyboard_event *) (e), (bool *) (k)) |
| dom_exception _dom_keyboard_event_get_modifier_state(dom_keyboard_event *evt, |
| dom_string *m, bool *state); |
| #define dom_keyboard_event_get_modifier_state(e, m, s) \ |
| _dom_keyboard_event_get_modifier_state( \ |
| (dom_keyboard_event *) (e), (dom_string *) (m),\ |
| (bool *) (s)) |
| dom_exception _dom_keyboard_event_init(dom_keyboard_event *evt, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_abstract_view *view, dom_string *key_ident, |
| dom_key_location key_loc, dom_string *modifier_list); |
| #define dom_keyboard_event_init(e, t, b, c, v, ki, kl, m) \ |
| _dom_keyboard_event_init((dom_keyboard_event *) (e), \ |
| (dom_string *) (t), (bool) (b), (bool) (c), \ |
| (struct dom_abstract_view *) (v), (dom_string *) (ki), \ |
| (dom_key_location) (kl), (dom_string *) (m)) |
| dom_exception _dom_keyboard_event_init_ns(dom_keyboard_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, struct dom_abstract_view *view, |
| dom_string *key_ident, dom_key_location key_loc, |
| dom_string *modifier_list); |
| #define dom_keyboard_event_init_ns(e, n, t, b, c, v, ki, kl, m) \ |
| _dom_keyboard_event_init_ns((dom_keyboard_event *) (e), \ |
| (dom_string *) (n), (dom_string *) (t), \ |
| (bool) (b), (bool) (c), (struct dom_abstract_view *) (v), \ |
| (dom_string *) (ki), (dom_key_location) (kl), \ |
| (dom_string *) (m)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/mouse_event.h |
|---|
| 0,0 → 1,108 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_mouse_event_h_ |
| #define dom_events_mouse_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| #include <dom/events/event_target.h> |
| struct dom_abstract_view; |
| typedef struct dom_mouse_event dom_mouse_event; |
| dom_exception _dom_mouse_event_get_screen_x(dom_mouse_event *evt, |
| int32_t *x); |
| #define dom_mouse_event_get_screen_x(e, x) _dom_mouse_event_get_screen_x(\ |
| (dom_mouse_event *) (e), (int32_t *) (x)) |
| dom_exception _dom_mouse_event_get_screen_y(dom_mouse_event *evt, |
| int32_t *y); |
| #define dom_mouse_event_get_screen_y(e, y) _dom_mouse_event_get_screen_y(\ |
| (dom_mouse_event *) (e), (int32_t *) (y)) |
| dom_exception _dom_mouse_event_get_client_x(dom_mouse_event *evt, |
| int32_t *x); |
| #define dom_mouse_event_get_client_x(e, x) _dom_mouse_event_get_client_x(\ |
| (dom_mouse_event *) (e), (int32_t *) (x)) |
| dom_exception _dom_mouse_event_get_client_y(dom_mouse_event *evt, |
| int32_t *y); |
| #define dom_mouse_event_get_client_y(e, y) _dom_mouse_event_get_client_y(\ |
| (dom_mouse_event *) (e), (int32_t *) (y)) |
| dom_exception _dom_mouse_event_get_ctrl_key(dom_mouse_event *evt, |
| bool *key); |
| #define dom_mouse_event_get_ctrl_key(e, k) _dom_mouse_event_get_ctrl_key( \ |
| (dom_mouse_event *) (e), (bool *) (k)) |
| dom_exception _dom_mouse_event_get_shift_key(dom_mouse_event *evt, |
| bool *key); |
| #define dom_mouse_event_get_shift_key(e, k) _dom_mouse_event_get_shift_key( \ |
| (dom_mouse_event *) (e), (bool *) (k)) |
| dom_exception _dom_mouse_event_get_alt_key(dom_mouse_event *evt, |
| bool *key); |
| #define dom_mouse_event_get_alt_key(e, k) _dom_mouse_event_get_alt_key( \ |
| (dom_mouse_event *) (e), (bool *) (k)) |
| dom_exception _dom_mouse_event_get_meta_key(dom_mouse_event *evt, |
| bool *key); |
| #define dom_mouse_event_get_meta_key(e, k) _dom_mouse_event_get_meta_key( \ |
| (dom_mouse_event *) (e), (bool *) (k)) |
| dom_exception _dom_mouse_event_get_button(dom_mouse_event *evt, |
| unsigned short *button); |
| #define dom_mouse_event_get_button(e, b) _dom_mouse_event_get_button(\ |
| (dom_mouse_event *) (e), (unsigned short *) (b)) |
| dom_exception _dom_mouse_event_get_related_target(dom_mouse_event *evt, |
| dom_event_target **et); |
| #define dom_mouse_event_get_related_target(e, t) \ |
| _dom_mouse_event_get_related_target((dom_mouse_event *) (e),\ |
| (dom_event_target **) (t)) |
| dom_exception _dom_mouse_event_get_modifier_state(dom_mouse_event *evt, |
| dom_string *m, bool *state); |
| #define dom_mouse_event_get_modifier_state(e, m, s) \ |
| _dom_mouse_event_get_modifier_state((dom_mouse_event *) (e), \ |
| (dom_string *) (m), (bool *) (s)) |
| dom_exception _dom_mouse_event_init(dom_mouse_event *evt, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_abstract_view *view, int32_t detail, int32_t screen_x, |
| int32_t screen_y, int32_t client_x, int32_t client_y, bool ctrl, |
| bool alt, bool shift, bool meta, unsigned short button, |
| dom_event_target *et); |
| #define dom_mouse_event_init(e, t, b, c, v, d, sx, sy, cx, cy, ctrl, alt, \ |
| shift, meta, button, et) \ |
| _dom_mouse_event_init((dom_mouse_event *) (e), \ |
| (dom_string *) (t), (bool) (b), (bool) (c),\ |
| (struct dom_abstract_view *) (v), (int32_t) (d), (int32_t) (sx), \ |
| (int32_t) (sy), (int32_t) (cx), (int32_t) (cy), (bool) (ctrl),\ |
| (bool) (alt), (bool) (shift), (bool) (meta), \ |
| (unsigned short) (button), (dom_event_target *) (et)) |
| dom_exception _dom_mouse_event_init_ns(dom_mouse_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, struct dom_abstract_view *view, |
| int32_t detail, int32_t screen_x, int32_t screen_y, int32_t client_x, |
| int32_t client_y, bool ctrl, bool alt, bool shift, bool meta, |
| unsigned short button, dom_event_target *et); |
| #define dom_mouse_event_init_ns(e, n, t, b, c, v, d, sx, sy, cx, cy, ctrl, alt,\ |
| shift, meta, button, et) \ |
| _dom_mouse_event_init_ns((dom_mouse_event *) (e), \ |
| (dom_string *) (n), (dom_string *) (t),\ |
| (bool) (b), (bool) (c), (struct dom_abstract_view *) (v),\ |
| (int32_t) (d), (int32_t) (sx), (int32_t) (sy), (int32_t) (cx),\ |
| (int32_t) (cy), (bool) (ctrl), (bool) (alt), (bool) (shift),\ |
| (bool) (meta), (unsigned short) (button),\ |
| (dom_event_target *) (et)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/mouse_multi_wheel_event.h |
|---|
| 0,0 → 1,56 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_mouse_multi_wheel_event_h_ |
| #define dom_events_mouse_multi_wheel_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| #include <dom/events/event_target.h> |
| struct dom_abstract_view; |
| typedef struct dom_mouse_multi_wheel_event dom_mouse_multi_wheel_event; |
| dom_exception _dom_mouse_multi_wheel_event_get_wheel_delta_x( |
| dom_mouse_multi_wheel_event *evt, int32_t *x); |
| #define dom_mouse_multi_wheel_event_get_wheel_delta_x(e, x) \ |
| _dom_mouse_multi_wheel_event_get_wheel_delta_x( \ |
| (dom_mouse_multi_wheel_event *) (e), (int32_t *) (x)) |
| dom_exception _dom_mouse_multi_wheel_event_get_wheel_delta_y( |
| dom_mouse_multi_wheel_event *evt, int32_t *y); |
| #define dom_mouse_multi_wheel_event_get_wheel_delta_y(e, y) \ |
| _dom_mouse_multi_wheel_event_get_wheel_delta_y( \ |
| (dom_mouse_multi_wheel_event *) (e), (int32_t *) (y)) |
| dom_exception _dom_mouse_multi_wheel_event_get_wheel_delta_z( |
| dom_mouse_multi_wheel_event *evt, int32_t *z); |
| #define dom_mouse_multi_wheel_event_get_wheel_delta_z(e, z) \ |
| _dom_mouse_multi_wheel_event_get_wheel_delta_z( \ |
| (dom_mouse_multi_wheel_event *) (e), (int32_t *) (z)) |
| dom_exception _dom_mouse_multi_wheel_event_init_ns( |
| dom_mouse_multi_wheel_event *evt, dom_string *namespace, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_abstract_view *view, int32_t detail, int32_t screen_x, |
| int32_t screen_y, int32_t client_x, int32_t client_y, |
| unsigned short button, dom_event_target *et, |
| dom_string *modifier_list, int32_t wheel_delta_x, |
| int32_t wheel_delta_y, int32_t wheel_delta_z); |
| #define dom_mouse_multi_wheel_event_init_ns(e, n, t, b, c, v, \ |
| d, sx, sy, cx, cy, button, et, ml, x, y, z) \ |
| _dom_mouse_multi_wheel_event_init_ns( \ |
| (dom_mouse_multi_wheel_event *) (e), (dom_string *) (n),\ |
| (dom_string *) (t), (bool) (b), (bool) (c), \ |
| (struct dom_abstract_view *) (v), (int32_t) (d), (int32_t) (sx), \ |
| (int32_t) (sy), (int32_t) (cx), (int32_t) (cy),\ |
| (unsigned short) (button), (dom_event_target *) (et),\ |
| (dom_string *) (ml), (int32_t) (x), (int32_t) (y), (int32_t) (z)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/mouse_wheel_event.h |
|---|
| 0,0 → 1,42 |
| /* * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_mouse_wheel_event_h_ |
| #define dom_events_mouse_wheel_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| #include <dom/events/event_target.h> |
| struct dom_abstract_view; |
| typedef struct dom_mouse_wheel_event dom_mouse_wheel_event; |
| dom_exception _dom_mouse_wheel_event_get_wheel_delta( |
| dom_mouse_wheel_event *evt, int32_t *d); |
| #define dom_mouse_wheel_event_get_wheel_delta(e, d) \ |
| _dom_mouse_wheel_event_get_wheel_delta( \ |
| (dom_mouse_wheel_event *) (e), (int32_t *) (d)) |
| dom_exception _dom_mouse_wheel_event_init_ns( |
| dom_mouse_wheel_event *evt, dom_string *namespace, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_abstract_view *view, int32_t detail, int32_t screen_x, |
| int32_t screen_y, int32_t client_x, int32_t client_y, |
| unsigned short button, dom_event_target *et, |
| dom_string *modifier_list, int32_t wheel_delta); |
| #define dom_mouse_wheel_event_init_ns(e, n, t, b, c, v, \ |
| d, sx, sy, cx, cy, button, et, ml, dt) \ |
| _dom_mouse_wheel_event_init_ns((dom_mouse_wheel_event *) (e), \ |
| (dom_string *) (n), (dom_string *) (t), \ |
| (bool) (b), (bool) (c), (struct dom_abstract_view *) (v),\ |
| (int32_t) (d), (int32_t) (sx), (int32_t) (sy), (int32_t) (cx), (int32_t) (cy),\ |
| (unsigned short) (button), (dom_event_target *) (et),\ |
| (dom_string *) (ml), (int32_t) (dt)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/mutation_event.h |
|---|
| 0,0 → 1,80 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_mutation_event_h_ |
| #define dom_events_mutation_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_node; |
| typedef enum { |
| DOM_MUTATION_MODIFICATION = 1, |
| DOM_MUTATION_ADDITION = 2, |
| DOM_MUTATION_REMOVAL = 3 |
| } dom_mutation_type; |
| typedef struct dom_mutation_event dom_mutation_event; |
| dom_exception _dom_mutation_event_get_related_node(dom_mutation_event *evt, |
| struct dom_node **node); |
| #define dom_mutation_event_get_related_node(e, n) \ |
| _dom_mutation_event_get_related_node(\ |
| (dom_mutation_event *) (e), (struct dom_node **) (n)) |
| dom_exception _dom_mutation_event_get_prev_value(dom_mutation_event *evt, |
| dom_string **ret); |
| #define dom_mutation_event_get_prev_value(e, r) \ |
| _dom_mutation_event_get_prev_value((dom_mutation_event *) (e), \ |
| (dom_string **) (r)) |
| dom_exception _dom_mutation_event_get_new_value(dom_mutation_event *evt, |
| dom_string **ret); |
| #define dom_mutation_event_get_new_value(e, r) \ |
| _dom_mutation_event_get_new_value((dom_mutation_event *) (e), \ |
| (dom_string **) (r)) |
| dom_exception _dom_mutation_event_get_attr_name(dom_mutation_event *evt, |
| dom_string **ret); |
| #define dom_mutation_event_get_attr_name(e, r) \ |
| _dom_mutation_event_get_attr_name((dom_mutation_event *) (e), \ |
| (dom_string **) (r)) |
| dom_exception _dom_mutation_event_get_attr_change(dom_mutation_event *evt, |
| dom_mutation_type *type); |
| #define dom_mutation_event_get_attr_change(e, t) \ |
| _dom_mutation_event_get_attr_change((dom_mutation_event *) (e),\ |
| (dom_mutation_type *) (t)) |
| dom_exception _dom_mutation_event_init(dom_mutation_event *evt, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_node *node, dom_string *prev_value, |
| dom_string *new_value, dom_string *attr_name, |
| dom_mutation_type change); |
| #define dom_mutation_event_init(e, t, b, c, n, p, nv, a, ch) \ |
| _dom_mutation_event_init((dom_mutation_event *) (e), \ |
| (dom_string *) (t), (bool) (b), (bool) (c), \ |
| (struct dom_node *) (n), (dom_string *) (p), \ |
| (dom_string *) (nv), (dom_string *) (a), \ |
| (dom_mutation_type) (ch)) |
| dom_exception _dom_mutation_event_init_ns(dom_mutation_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, struct dom_node *node, |
| dom_string *prev_value, dom_string *new_value, |
| dom_string *attr_name, dom_mutation_type change); |
| #define dom_mutation_event_init_ns(e, n, t, b, c, nd, p, nv, a, ch) \ |
| _dom_mutation_event_init_ns((dom_mutation_event *) (e), \ |
| (dom_string *) (n), (dom_string *) (t),\ |
| (bool) (b), (bool) (c), (struct dom_node *) (nd), \ |
| (dom_string *) (p), (dom_string *) (nv),\ |
| (dom_string *) (a), (dom_mutation_type) (ch)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/mutation_name_event.h |
|---|
| 0,0 → 1,54 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_mutation_name_event_h_ |
| #define dom_events_mutation_name_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_node; |
| typedef struct dom_mutation_name_event dom_mutation_name_event; |
| dom_exception _dom_mutation_name_event_get_prev_namespace( |
| dom_mutation_name_event *evt, dom_string **namespace); |
| #define dom_mutation_name_event_get_prev_namespace(e, n) \ |
| _dom_mutation_name_event_get_prev_namespace(\ |
| (dom_mutation_name_event *) (e), (dom_string **) (n)) |
| dom_exception _dom_mutation_name_event_get_prev_node_name( |
| dom_mutation_name_event *evt, dom_string **name); |
| #define dom_mutation_name_event_get_prev_node_name(e, n) \ |
| _dom_mutation_name_event_get_prev_node_name(\ |
| (dom_mutation_name_event *) (e), (dom_string **) (n)) |
| dom_exception _dom_mutation_name_event_init(dom_mutation_name_event *evt, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_node *node, dom_string *prev_ns, |
| dom_string *prev_name); |
| #define dom_mutation_name_event_init(e, t, b, c, n, p, pn) \ |
| _dom_mutation_name_event_init((dom_mutation_name_event *) (e), \ |
| (dom_string *) (t), (bool) (b), (bool) (c), \ |
| (struct dom_node *) (n), (dom_string *) (p), \ |
| (dom_string *) (pn)) |
| dom_exception _dom_mutation_name_event_init_ns(dom_mutation_name_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, struct dom_node *node, |
| dom_string *prev_ns, dom_string *prev_name); |
| #define dom_mutation_name_event_init_ns(e, n, t, b, c, nv, p, pn) \ |
| _dom_mutation_name_event_init_ns(\ |
| (dom_mutation_name_event *) (e), (dom_string *) (n),\ |
| (dom_string *) (t), (bool) (b), (bool) (c),\ |
| (struct dom_node *) (nv), (dom_string *) (p), \ |
| (dom_string *) (pn)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/text_event.h |
|---|
| 0,0 → 1,41 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_text_event_h_ |
| #define dom_events_text_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_abstract_view; |
| typedef struct dom_text_event dom_text_event; |
| dom_exception _dom_text_event_get_data(dom_text_event *evt, |
| dom_string **data); |
| #define dom_text_event_get_data(e, d) _dom_text_event_get_data(\ |
| (dom_text_event *) (e), (dom_string **) (d)) |
| dom_exception _dom_text_event_init(dom_text_event *evt, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_abstract_view *view, dom_string *data); |
| #define dom_text_event_init(e, t, b, c, v, d) _dom_text_event_init( \ |
| (dom_text_event *) (e), (dom_string *) (t), (bool) (b), \ |
| (bool) (c), (struct dom_abstract_view *) (v),\ |
| (dom_string *) (d)) |
| dom_exception _dom_text_event_init_ns(dom_text_event *evt, |
| dom_string *namespace_name, dom_string *type, |
| bool bubble, bool cancelable, struct dom_abstract_view *view, |
| dom_string *data); |
| #define dom_text_event_init_ns(e, n, t, b, c, v, d) _dom_text_event_init_ns( \ |
| (dom_text_event *) (e), (dom_string *) (n), \ |
| (dom_string *) (t), (bool) (b), (bool) (c), \ |
| (struct dom_abstract_view *) (v), (dom_string *) (d)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/events/ui_event.h |
|---|
| 0,0 → 1,45 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_ui_event_h_ |
| #define dom_events_ui_event_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_abstract_view; |
| typedef struct dom_ui_event dom_ui_event; |
| dom_exception _dom_ui_event_get_view(dom_ui_event *evt, |
| struct dom_abstract_view **view); |
| #define dom_ui_event_get_view(e, v) _dom_ui_event_get_view( \ |
| (dom_ui_event *) (e), (struct dom_abstract_view **) (v)) |
| dom_exception _dom_ui_event_get_detail(dom_ui_event *evt, |
| int32_t *detail); |
| #define dom_ui_event_get_detail(e, d) _dom_ui_event_get_detail(\ |
| (dom_ui_event *) (e), (int32_t *) (d)) |
| dom_exception _dom_ui_event_init(dom_ui_event *evt, dom_string *type, |
| bool bubble, bool cancelable, struct dom_abstract_view *view, |
| int32_t detail); |
| #define dom_ui_event_init(e, t, b, c, v, d) _dom_ui_event_init( \ |
| (dom_ui_event *) (e), (dom_string *) (t), (bool) (b), \ |
| (bool) (c), (struct dom_abstract_view *) (v), (int32_t) (d)) |
| dom_exception _dom_ui_event_init_ns(dom_ui_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, struct dom_abstract_view *view, |
| int32_t detail); |
| #define dom_ui_event_init_ns(e, n, t, b, c, v, d) _dom_ui_event_init_ns( \ |
| (dom_ui_event *) (e), (dom_string *) (n), \ |
| (dom_string *) (t), (bool) (b), (bool) (c), \ |
| (struct dom_abstract_view *) (v), (int32_t) (d)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/functypes.h |
|---|
| 0,0 → 1,35 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_functypes_h_ |
| #define dom_functypes_h_ |
| #include <stddef.h> |
| #include <inttypes.h> |
| typedef unsigned int uint32_t; |
| /** |
| * Severity levels for dom_msg function, based on syslog(3) |
| */ |
| enum { |
| DOM_MSG_DEBUG, |
| DOM_MSG_INFO, |
| DOM_MSG_NOTICE, |
| DOM_MSG_WARNING, |
| DOM_MSG_ERROR, |
| DOM_MSG_CRITICAL, |
| DOM_MSG_ALERT, |
| DOM_MSG_EMERGENCY |
| }; |
| /** |
| * Type of DOM message function |
| */ |
| typedef void (*dom_msg)(uint32_t severity, void *ctx, const char *msg, ...); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_anchor_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_applet_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_area_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_base_element.h |
|---|
| 0,0 → 1,14 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_html_base_element_h_ |
| #define dom_html_base_element_h_ |
| typedef struct dom_html_base_element dom_html_base_element; |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_basefont_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_body_element.h |
|---|
| 0,0 → 1,53 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #ifndef dom_html_body_element_h_ |
| #define dom_html_body_element_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| typedef struct dom_html_body_element dom_html_body_element; |
| dom_exception dom_html_body_element_get_a_link(dom_html_body_element *ele, |
| dom_string **a_link); |
| dom_exception dom_html_body_element_set_a_link(dom_html_body_element *ele, |
| dom_string *a_link); |
| dom_exception dom_html_body_element_get_v_link(dom_html_body_element *ele, |
| dom_string **v_link); |
| dom_exception dom_html_body_element_set_v_link(dom_html_body_element *ele, |
| dom_string *v_link); |
| dom_exception dom_html_body_element_get_background(dom_html_body_element *ele, |
| dom_string **background); |
| dom_exception dom_html_body_element_set_background(dom_html_body_element *ele, |
| dom_string *background); |
| dom_exception dom_html_body_element_get_bg_color(dom_html_body_element *ele, |
| dom_string **bg_color); |
| dom_exception dom_html_body_element_set_bg_color(dom_html_body_element *ele, |
| dom_string *bg_color); |
| dom_exception dom_html_body_element_get_link(dom_html_body_element *ele, |
| dom_string **link); |
| dom_exception dom_html_body_element_set_link(dom_html_body_element *ele, |
| dom_string *link); |
| dom_exception dom_html_body_element_get_text(dom_html_body_element *ele, |
| dom_string **text); |
| dom_exception dom_html_body_element_set_text(dom_html_body_element *ele, |
| dom_string *text); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_br_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_button_element.h |
|---|
| 0,0 → 1,54 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #ifndef dom_html_button_element_h_ |
| #define dom_html_button_element_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| #include <dom/html/html_form_element.h> |
| typedef struct dom_html_button_element dom_html_button_element; |
| dom_exception dom_html_button_element_get_form( |
| dom_html_button_element *button, dom_html_form_element **form); |
| dom_exception dom_html_button_element_get_access_key( |
| dom_html_button_element *button, dom_string **access_key); |
| dom_exception dom_html_button_element_set_access_key( |
| dom_html_button_element *button, dom_string *access_key); |
| dom_exception dom_html_button_element_get_disabled( |
| dom_html_button_element *button, bool *disabled); |
| dom_exception dom_html_button_element_set_disabled( |
| dom_html_button_element *button, bool disabled); |
| dom_exception dom_html_button_element_get_name( |
| dom_html_button_element *button, dom_string **name); |
| dom_exception dom_html_button_element_set_name( |
| dom_html_button_element *button, dom_string *name); |
| dom_exception dom_html_button_element_get_tab_index( |
| dom_html_button_element *button, int32_t *tab_index); |
| dom_exception dom_html_button_element_set_tab_index( |
| dom_html_button_element *button, uint32_t tab_index); |
| dom_exception dom_html_button_element_get_type( |
| dom_html_button_element *button, dom_string **type); |
| dom_exception dom_html_button_element_get_value( |
| dom_html_button_element *button, dom_string **value); |
| dom_exception dom_html_button_element_set_value( |
| dom_html_button_element *button, dom_string *value); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_collection.h |
|---|
| 0,0 → 1,29 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_html_collection_h_ |
| #define dom_html_collection_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_node; |
| typedef struct dom_html_collection dom_html_collection; |
| dom_exception dom_html_collection_get_length(dom_html_collection *col, |
| uint32_t *len); |
| dom_exception dom_html_collection_item(dom_html_collection *col, |
| uint32_t index, struct dom_node **node); |
| dom_exception dom_html_collection_named_item(dom_html_collection *col, |
| dom_string *name, struct dom_node **node); |
| void dom_html_collection_ref(dom_html_collection *col); |
| void dom_html_collection_unref(dom_html_collection *col); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_directory_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_div_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_dlist_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_document.h |
|---|
| 0,0 → 1,245 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_html_document_h_ |
| #define dom_html_document_h_ |
| #include <dom/core/document.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/functypes.h> |
| #include <dom/events/document_event.h> |
| struct dom_element; |
| struct dom_html_collection; |
| struct dom_html_element; |
| struct dom_nodelist; |
| typedef struct dom_html_document dom_html_document; |
| typedef struct dom_html_document_vtable { |
| struct dom_document_vtable base; |
| dom_exception (*get_title)(dom_html_document *doc, |
| dom_string **title); |
| dom_exception (*set_title)(dom_html_document *doc, |
| dom_string *title); |
| dom_exception (*get_referrer)(dom_html_document *doc, |
| dom_string **referrer); |
| dom_exception (*get_domain)(dom_html_document *doc, |
| dom_string **domain); |
| dom_exception (*get_url)(dom_html_document *doc, |
| dom_string **url); |
| dom_exception (*get_body)(dom_html_document *doc, |
| struct dom_html_element **body); |
| dom_exception (*set_body)(dom_html_document *doc, |
| struct dom_html_element *body); |
| dom_exception (*get_images)(dom_html_document *doc, |
| struct dom_html_collection **col); |
| dom_exception (*get_applets)(dom_html_document *doc, |
| struct dom_html_collection **col); |
| dom_exception (*get_links)(dom_html_document *doc, |
| struct dom_html_collection **col); |
| dom_exception (*get_forms)(dom_html_document *doc, |
| struct dom_html_collection **col); |
| dom_exception (*get_anchors)(dom_html_document *doc, |
| struct dom_html_collection **col); |
| dom_exception (*get_cookie)(dom_html_document *doc, |
| dom_string **cookie); |
| dom_exception (*set_cookie)(dom_html_document *doc, |
| dom_string *cookie); |
| dom_exception (*open)(dom_html_document *doc); |
| dom_exception (*close)(dom_html_document *doc); |
| dom_exception (*write)(dom_html_document *doc, |
| dom_string *text); |
| dom_exception (*writeln)(dom_html_document *doc, |
| dom_string *text); |
| dom_exception (*get_elements_by_name)(dom_html_document *doc, |
| dom_string *name, struct dom_nodelist **list); |
| } dom_html_document_vtable; |
| static inline dom_exception dom_html_document_get_title( |
| dom_html_document *doc, dom_string **title) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_title(doc, title); |
| } |
| #define dom_html_document_get_title(d, t) \ |
| dom_html_document_get_title((dom_html_document *) (d), (t)) |
| static inline dom_exception dom_html_document_set_title(dom_html_document *doc, |
| dom_string *title) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| set_title(doc, title); |
| } |
| #define dom_html_document_set_title(d, t) \ |
| dom_html_document_set_title((dom_html_document *) (d), (t)) |
| static inline dom_exception dom_html_document_get_referrer(dom_html_document *doc, |
| dom_string **referrer) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_referrer(doc, referrer); |
| } |
| #define dom_html_document_get_referrer(d, r) \ |
| dom_html_document_get_referrer((dom_html_document *) (d), (r)) |
| static inline dom_exception dom_html_document_get_domain(dom_html_document *doc, |
| dom_string **domain) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_domain(doc, domain); |
| } |
| #define dom_html_document_get_domain(d, t) \ |
| dom_html_document_get_domain((dom_html_document *) (d), (t)) |
| static inline dom_exception dom_html_document_get_url(dom_html_document *doc, |
| dom_string **url) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_url(doc, url); |
| } |
| #define dom_html_document_get_url(d, u) \ |
| dom_html_document_get_url((dom_html_document *) (d), (u)) |
| static inline dom_exception dom_html_document_get_body(dom_html_document *doc, |
| struct dom_html_element **body) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_body(doc, body); |
| } |
| #define dom_html_document_get_body(d, b) \ |
| dom_html_document_get_title((dom_html_document *) (d), \ |
| (struct dom_html_element **) (b)) |
| static inline dom_exception dom_html_document_set_body(dom_html_document *doc, |
| struct dom_html_element *body) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| set_body(doc, body); |
| } |
| #define dom_html_document_set_body(d, b) \ |
| dom_html_document_set_body((dom_html_document *) (d), \ |
| (struct dom_html_element **) (b)) |
| static inline dom_exception dom_html_document_get_images(dom_html_document *doc, |
| struct dom_html_collection **col) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_images(doc, col); |
| } |
| #define dom_html_document_get_images(d, c) \ |
| dom_html_document_get_images((dom_html_document *) (d), \ |
| (struct dom_html_collection **) (c)) |
| static inline dom_exception dom_html_document_get_applets(dom_html_document *doc, |
| struct dom_html_collection **col) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_applets(doc, col); |
| } |
| #define dom_html_document_get_applets(d, c) \ |
| dom_html_document_get_applets((dom_html_document *) (d), \ |
| (struct dom_html_collection **) (c)) |
| static inline dom_exception dom_html_document_get_links(dom_html_document *doc, |
| struct dom_html_collection **col) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_links(doc, col); |
| } |
| #define dom_html_document_get_links(d, c) \ |
| dom_html_document_get_links((dom_html_document *) (d), \ |
| (struct dom_html_collection **) (c)) |
| static inline dom_exception dom_html_document_get_forms(dom_html_document *doc, |
| struct dom_html_collection **col) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_forms(doc, col); |
| } |
| #define dom_html_document_get_forms(d, c) \ |
| dom_html_document_get_forms((dom_html_document *) (d), \ |
| (struct dom_html_collection **) (c)) |
| static inline dom_exception dom_html_document_get_anchors(dom_html_document *doc, |
| struct dom_html_collection **col) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_anchors(doc, col); |
| } |
| #define dom_html_document_get_anchors(d, c) \ |
| dom_html_document_get_title((dom_html_document *) (d), \ |
| (struct dom_html_collection **) (c)) |
| static inline dom_exception dom_html_document_get_cookie(dom_html_document *doc, |
| dom_string **cookie) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_cookie(doc, cookie); |
| } |
| #define dom_html_document_get_cookie(d, c) \ |
| dom_html_document_get_title((dom_html_document *) (d), (c)) |
| static inline dom_exception dom_html_document_set_cookie(dom_html_document *doc, |
| dom_string *cookie) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| set_cookie(doc, cookie); |
| } |
| #define dom_html_document_set_cookie(d, c) \ |
| dom_html_document_set_cookie((dom_html_document *) (d), (c)) |
| static inline dom_exception dom_html_document_open(dom_html_document *doc) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| open(doc); |
| } |
| #define dom_html_document_open(d) \ |
| dom_html_document_open((dom_html_document *) (d)) |
| static inline dom_exception dom_html_document_close(dom_html_document *doc) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| close(doc); |
| } |
| #define dom_html_document_close(d) \ |
| dom_html_document_close((dom_html_document *) (d)) |
| static inline dom_exception dom_html_document_write(dom_html_document *doc, |
| dom_string *text) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| write(doc, text); |
| } |
| #define dom_html_document_write(d, t) \ |
| dom_html_document_write((dom_html_document *) (d), (t)) |
| static inline dom_exception dom_html_document_writeln(dom_html_document *doc, |
| dom_string *text) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| writeln(doc, text); |
| } |
| #define dom_html_document_writeln(d, t) \ |
| dom_html_document_writeln((dom_html_document *) (d), (t)) |
| static inline dom_exception dom_html_document_get_elements_by_name(dom_html_document *doc, |
| dom_string *name, struct dom_nodelist **list) |
| { |
| return ((dom_html_document_vtable *) ((dom_node *) doc)->vtable)-> |
| get_elements_by_name(doc, name, list); |
| } |
| #define dom_html_document_get_elements_by_name(d, n, l) \ |
| dom_html_document_get_element_by_name((dom_html_document *) (d), \ |
| (n), (struct dom_nodelist **) (l)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_element.h |
|---|
| 0,0 → 1,131 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_html_element_h_ |
| #define dom_html_element_h_ |
| #include <dom/core/element.h> |
| typedef struct dom_html_element dom_html_element; |
| typedef struct dom_html_element_vtable { |
| struct dom_element_vtable base; |
| dom_exception (*dom_html_element_get_id)(struct dom_html_element *element, |
| dom_string **id); |
| dom_exception (*dom_html_element_set_id)(struct dom_html_element *element, |
| dom_string *id); |
| dom_exception (*dom_html_element_get_title)(struct dom_html_element *element, |
| dom_string **title); |
| dom_exception (*dom_html_element_set_title)(struct dom_html_element *element, |
| dom_string *title); |
| dom_exception (*dom_html_element_get_lang)(struct dom_html_element *element, |
| dom_string **lang); |
| dom_exception (*dom_html_element_set_lang)(struct dom_html_element *element, |
| dom_string *lang); |
| dom_exception (*dom_html_element_get_dir)(struct dom_html_element *element, |
| dom_string **dir); |
| dom_exception (*dom_html_element_set_dir)(struct dom_html_element *element, |
| dom_string *dir); |
| dom_exception (*dom_html_element_get_class_name)(struct dom_html_element *element, |
| dom_string **class_name); |
| dom_exception (*dom_html_element_set_class_name)(struct dom_html_element *element, |
| dom_string *class_name); |
| } dom_html_element_vtable; |
| static inline dom_exception dom_html_element_get_id(struct dom_html_element *element, |
| dom_string **id) |
| { |
| return ((dom_html_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_html_element_get_id(element, id); |
| } |
| #define dom_html_element_get_id(e, id) dom_html_element_get_id( \ |
| (dom_html_element *) (e), (id)) |
| static inline dom_exception dom_html_element_set_id(struct dom_html_element *element, |
| dom_string *id) |
| { |
| return ((dom_html_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_html_element_set_id(element, id); |
| } |
| #define dom_html_element_set_id(e, id) dom_html_element_set_id( \ |
| (dom_html_element *) (e), (id)) |
| static inline dom_exception dom_html_element_get_title(struct dom_html_element *element, |
| dom_string **title) |
| { |
| return ((dom_html_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_html_element_get_title(element, title); |
| } |
| #define dom_html_element_get_title(e, title) dom_html_element_get_title( \ |
| (dom_html_element *) (e), (title)) |
| static inline dom_exception dom_html_element_set_title(struct dom_html_element *element, |
| dom_string *title) |
| { |
| return ((dom_html_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_html_element_set_title(element, title); |
| } |
| #define dom_html_element_set_title(e, title) dom_html_element_set_title( \ |
| (dom_html_element *) (e), (title)) |
| static inline dom_exception dom_html_element_get_lang(struct dom_html_element *element, |
| dom_string **lang) |
| { |
| return ((dom_html_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_html_element_get_lang(element, lang); |
| } |
| #define dom_html_element_get_lang(e, lang) dom_html_element_get_lang( \ |
| (dom_html_element *) (e), (lang)) |
| static inline dom_exception dom_html_element_set_lang(struct dom_html_element *element, |
| dom_string *lang) |
| { |
| return ((dom_html_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_html_element_set_lang(element, lang); |
| } |
| #define dom_html_element_set_lang(e, lang) dom_html_element_set_lang( \ |
| (dom_html_element *) (e), (lang)) |
| static inline dom_exception dom_html_element_get_dir(struct dom_html_element *element, |
| dom_string **dir) |
| { |
| return ((dom_html_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_html_element_get_dir(element, dir); |
| } |
| #define dom_html_element_get_dir(e, dir) dom_html_element_get_dir( \ |
| (dom_html_element *) (e), (dir)) |
| static inline dom_exception dom_html_element_set_dir(struct dom_html_element *element, |
| dom_string *dir) |
| { |
| return ((dom_html_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_html_element_set_dir(element, dir); |
| } |
| #define dom_html_element_set_dir(e, dir) dom_html_element_set_dir( \ |
| (dom_html_element *) (e), (dir)) |
| static inline dom_exception dom_html_element_get_class_name(struct dom_html_element *element, |
| dom_string **class_name) |
| { |
| return ((dom_html_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_html_element_get_class_name(element, class_name); |
| } |
| #define dom_html_element_get_class_name(e, class_name) dom_html_element_get_class_name( \ |
| (dom_html_element *) (e), (class_name)) |
| static inline dom_exception dom_html_element_set_class_name(struct dom_html_element *element, |
| dom_string *class_name) |
| { |
| return ((dom_html_element_vtable *) ((dom_node *) element)->vtable)-> |
| dom_html_element_set_class_name(element, class_name); |
| } |
| #define dom_html_element_set_class_name(e, class_name) dom_html_element_set_class_name( \ |
| (dom_html_element *) (e), (class_name)) |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_fieldset_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_font_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_form_element.h |
|---|
| 0,0 → 1,57 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_html_form_element_h_ |
| #define dom_html_form_element_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_html_collection; |
| typedef struct dom_html_form_element dom_html_form_element; |
| dom_exception dom_html_form_element_get_elements(dom_html_form_element *ele, |
| struct dom_html_collection **col); |
| dom_exception dom_html_form_element_get_length(dom_html_form_element *ele, |
| uint32_t *len); |
| dom_exception dom_html_form_element_get_accept_charset( |
| dom_html_form_element *ele, dom_string **accept_charset); |
| dom_exception dom_html_form_element_set_accept_charset( |
| dom_html_form_element *ele, dom_string *accept_charset); |
| dom_exception dom_html_form_element_get_action( |
| dom_html_form_element *ele, dom_string **action); |
| dom_exception dom_html_form_element_set_action( |
| dom_html_form_element *ele, dom_string *action); |
| dom_exception dom_html_form_element_get_enctype( |
| dom_html_form_element *ele, dom_string **enctype); |
| dom_exception dom_html_form_element_set_enctype( |
| dom_html_form_element *ele, dom_string *enctype); |
| dom_exception dom_html_form_element_get_method( |
| dom_html_form_element *ele, dom_string **method); |
| dom_exception dom_html_form_element_set_method( |
| dom_html_form_element *ele, dom_string *method); |
| dom_exception dom_html_form_element_get_target( |
| dom_html_form_element *ele, dom_string **target); |
| dom_exception dom_html_form_element_set_target( |
| dom_html_form_element *ele, dom_string *target); |
| dom_exception dom_html_form_element_submit(dom_html_form_element *ele); |
| dom_exception dom_html_form_element_reset(dom_html_form_element *ele); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_frame_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_frameset_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_head_element.h |
|---|
| 0,0 → 1,21 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_html_head_element_h_ |
| #define dom_html_head_element_h_ |
| #include <dom/html/html_element.h> |
| typedef struct dom_html_head_element dom_html_head_element; |
| dom_exception dom_html_head_element_get_profile( |
| struct dom_html_head_element *element, dom_string **profile); |
| dom_exception dom_html_head_element_set_profile( |
| struct dom_html_head_element *element, dom_string *profile); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_heading_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_hr_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_html_element.h |
|---|
| 0,0 → 1,22 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_html_html_element_h_ |
| #define dom_html_html_element_h_ |
| #include <dom/html/html_element.h> |
| typedef struct dom_html_html_element dom_html_html_element; |
| dom_exception dom_html_html_element_get_version( |
| struct dom_html_html_element *element, dom_string **version); |
| dom_exception dom_html_html_element_set_version( |
| struct dom_html_html_element *element, dom_string *version); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_iframe_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_image_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_input_element.h |
|---|
| 0,0 → 1,125 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #ifndef dom_html_input_element_h_ |
| #define dom_html_input_element_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| #include <dom/html/html_form_element.h> |
| typedef struct dom_html_input_element dom_html_input_element; |
| dom_exception dom_html_input_element_get_default_value( |
| dom_html_input_element *input, dom_string **default_value); |
| dom_exception dom_html_input_element_set_default_value( |
| dom_html_input_element *input, dom_string *default_value); |
| dom_exception dom_html_input_element_get_default_checked( |
| dom_html_input_element *input, bool *default_checked); |
| dom_exception dom_html_input_element_set_default_checked( |
| dom_html_input_element *input, bool default_checked); |
| dom_exception dom_html_input_element_get_form( |
| dom_html_input_element *input, dom_html_form_element **form); |
| dom_exception dom_html_input_element_get_accept( |
| dom_html_input_element *input, dom_string **accept); |
| dom_exception dom_html_input_element_set_accept( |
| dom_html_input_element *input, dom_string *accept); |
| dom_exception dom_html_input_element_get_access_key( |
| dom_html_input_element *input, dom_string **access_key); |
| dom_exception dom_html_input_element_set_access_key( |
| dom_html_input_element *input, dom_string *access_key); |
| dom_exception dom_html_input_element_get_align( |
| dom_html_input_element *input, dom_string **align); |
| dom_exception dom_html_input_element_set_align( |
| dom_html_input_element *input, dom_string *align); |
| dom_exception dom_html_input_element_get_alt( |
| dom_html_input_element *input, dom_string **alt); |
| dom_exception dom_html_input_element_set_alt( |
| dom_html_input_element *input, dom_string *alt); |
| dom_exception dom_html_input_element_get_checked( |
| dom_html_input_element *input, bool *checked); |
| dom_exception dom_html_input_element_set_checked( |
| dom_html_input_element *input, bool checked); |
| dom_exception dom_html_input_element_get_disabled( |
| dom_html_input_element *input, bool *disabled); |
| dom_exception dom_html_input_element_set_disabled( |
| dom_html_input_element *input, bool disabled); |
| dom_exception dom_html_input_element_get_max_length( |
| dom_html_input_element *input, int32_t *max_length); |
| dom_exception dom_html_input_element_set_max_length( |
| dom_html_input_element *input, uint32_t max_length); |
| dom_exception dom_html_input_element_get_name( |
| dom_html_input_element *input, dom_string **name); |
| dom_exception dom_html_input_element_set_name( |
| dom_html_input_element *input, dom_string *name); |
| dom_exception dom_html_input_element_get_read_only( |
| dom_html_input_element *input, bool *read_only); |
| dom_exception dom_html_input_element_set_read_only( |
| dom_html_input_element *input, bool read_only); |
| dom_exception dom_html_input_element_get_size( |
| dom_html_input_element *input, dom_string **size); |
| dom_exception dom_html_input_element_set_size( |
| dom_html_input_element *input, dom_string *size); |
| dom_exception dom_html_input_element_get_src( |
| dom_html_input_element *input, dom_string **src); |
| dom_exception dom_html_input_element_set_src( |
| dom_html_input_element *input, dom_string *src); |
| dom_exception dom_html_input_element_get_tab_index( |
| dom_html_input_element *input, int32_t *tab_index); |
| dom_exception dom_html_input_element_set_tab_index( |
| dom_html_input_element *input, uint32_t tab_index); |
| dom_exception dom_html_input_element_get_type( |
| dom_html_input_element *input, dom_string **type); |
| dom_exception dom_html_input_element_get_use_map( |
| dom_html_input_element *input, dom_string **use_map); |
| dom_exception dom_html_input_element_set_use_map( |
| dom_html_input_element *input, dom_string *use_map); |
| dom_exception dom_html_input_element_get_value( |
| dom_html_input_element *input, dom_string **value); |
| dom_exception dom_html_input_element_set_value( |
| dom_html_input_element *input, dom_string *value); |
| dom_exception dom_html_input_element_blur(dom_html_input_element *ele); |
| dom_exception dom_html_input_element_focus(dom_html_input_element *ele); |
| dom_exception dom_html_input_element_select(dom_html_input_element *ele); |
| dom_exception dom_html_input_element_click(dom_html_input_element *ele); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_isindex_element.h |
|---|
| 0,0 → 1,26 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_html_isindex_element_h_ |
| #define dom_html_isindex_element_h_ |
| #include <dom/core/exceptions.h> |
| struct dom_html_form_element; |
| /** |
| * Note: the HTML 4.01 spec said: this element is deprecated, use |
| * <INPUT> element instead. |
| */ |
| typedef struct dom_html_isindex_element dom_html_isindex_element; |
| dom_exception dom_html_isindex_element_get_form(dom_html_isindex_element *ele, |
| struct dom_html_form_element **form); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_label_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_legend_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_li_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_link_element.h |
|---|
| 0,0 → 1,72 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_html_link_element_h_ |
| #define dom_html_link_element_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| typedef struct dom_html_link_element dom_html_link_element; |
| dom_exception dom_html_link_element_get_disabled(dom_html_link_element *ele, |
| bool *disabled); |
| dom_exception dom_html_link_element_set_disabled(dom_html_link_element *ele, |
| bool disabled); |
| dom_exception dom_html_link_element_get_charset(dom_html_link_element *ele, |
| dom_string **charset); |
| dom_exception dom_html_link_element_set_charset(dom_html_link_element *ele, |
| dom_string *charset); |
| dom_exception dom_html_link_element_get_href(dom_html_link_element *ele, |
| dom_string **href); |
| dom_exception dom_html_link_element_set_href(dom_html_link_element *ele, |
| dom_string *href); |
| dom_exception dom_html_link_element_get_hreflang(dom_html_link_element *ele, |
| dom_string **hreflang); |
| dom_exception dom_html_link_element_set_hreflang(dom_html_link_element *ele, |
| dom_string *hreflang); |
| dom_exception dom_html_link_element_get_media(dom_html_link_element *ele, |
| dom_string **media); |
| dom_exception dom_html_link_element_set_media(dom_html_link_element *ele, |
| dom_string *media); |
| dom_exception dom_html_link_element_get_rel(dom_html_link_element *ele, |
| dom_string **rel); |
| dom_exception dom_html_link_element_set_rel(dom_html_link_element *ele, |
| dom_string *rel); |
| dom_exception dom_html_link_element_get_rev(dom_html_link_element *ele, |
| dom_string **rev); |
| dom_exception dom_html_link_element_set_rev(dom_html_link_element *ele, |
| dom_string *rev); |
| dom_exception dom_html_link_element_get_target(dom_html_link_element *ele, |
| dom_string **target); |
| dom_exception dom_html_link_element_set_target(dom_html_link_element *ele, |
| dom_string *target); |
| dom_exception dom_html_link_element_get_type(dom_html_link_element *ele, |
| dom_string **type); |
| dom_exception dom_html_link_element_set_type(dom_html_link_element *ele, |
| dom_string *type); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_map_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_menu_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_meta_element.h |
|---|
| 0,0 → 1,40 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_html_meta_element_h_ |
| #define dom_html_meta_element_h_ |
| #include <dom/core/string.h> |
| typedef struct dom_html_meta_element dom_html_meta_element; |
| dom_exception dom_html_meta_element_get_content(dom_html_meta_element *ele, |
| dom_string **content); |
| dom_exception dom_html_meta_element_set_content(dom_html_meta_element *ele, |
| dom_string *content); |
| dom_exception dom_html_meta_element_get_http_equiv(dom_html_meta_element *ele, |
| dom_string **http_equiv); |
| dom_exception dom_html_meta_element_set_http_equiv(dom_html_meta_element *ele, |
| dom_string *http_equiv); |
| dom_exception dom_html_meta_element_get_name(dom_html_meta_element *ele, |
| dom_string **name); |
| dom_exception dom_html_meta_element_set_name(dom_html_meta_element *ele, |
| dom_string *name); |
| dom_exception dom_html_meta_element_get_scheme(dom_html_meta_element *ele, |
| dom_string **scheme); |
| dom_exception dom_html_meta_element_set_scheme(dom_html_meta_element *ele, |
| dom_string *scheme); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_mod_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_object_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_olist_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_opt_group_element.h |
|---|
| 0,0 → 1,33 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #ifndef dom_html_opt_group_element_h_ |
| #define dom_html_opt_group_element_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| #include <dom/html/html_form_element.h> |
| typedef struct dom_html_opt_group_element dom_html_opt_group_element; |
| dom_exception dom_html_opt_group_element_get_form( |
| dom_html_opt_group_element *opt_group, dom_html_form_element **form); |
| dom_exception dom_html_opt_group_element_get_disabled( |
| dom_html_opt_group_element *opt_group, bool *disabled); |
| dom_exception dom_html_opt_group_element_set_disabled( |
| dom_html_opt_group_element *opt_group, bool disabled); |
| dom_exception dom_html_opt_group_element_get_label( |
| dom_html_opt_group_element *opt_group, dom_string **label); |
| dom_exception dom_html_opt_group_element_set_label( |
| dom_html_opt_group_element *opt_group, dom_string *label); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_option_element.h |
|---|
| 0,0 → 1,57 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_html_option_element_h_ |
| #define dom_html_option_element_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| #include <dom/html/html_form_element.h> |
| typedef struct dom_html_option_element dom_html_option_element; |
| dom_exception dom_html_option_element_get_form( |
| dom_html_option_element *option, dom_html_form_element **form); |
| dom_exception dom_html_option_element_get_default_selected( |
| dom_html_option_element *option, bool *default_selected); |
| dom_exception dom_html_option_element_set_default_selected( |
| dom_html_option_element *option, bool default_selected); |
| dom_exception dom_html_option_element_get_text( |
| dom_html_option_element *option, dom_string **text); |
| dom_exception dom_html_option_element_get_index( |
| dom_html_option_element *option, unsigned long *index); |
| dom_exception dom_html_option_element_get_disabled( |
| dom_html_option_element *option, bool *disabled); |
| dom_exception dom_html_option_element_set_disabled( |
| dom_html_option_element *option, bool disabled); |
| dom_exception dom_html_option_element_get_label( |
| dom_html_option_element *option, dom_string **label); |
| dom_exception dom_html_option_element_set_label( |
| dom_html_option_element *option, dom_string *label); |
| dom_exception dom_html_option_element_get_selected( |
| dom_html_option_element *option, bool *selected); |
| dom_exception dom_html_option_element_set_selected( |
| dom_html_option_element *option, bool selected); |
| dom_exception dom_html_option_element_get_value( |
| dom_html_option_element *option, dom_string **value); |
| dom_exception dom_html_option_element_set_value( |
| dom_html_option_element *option, dom_string *value); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_options_collection.h |
|---|
| 0,0 → 1,33 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_html_options_collection_h_ |
| #define dom_html_options_collection_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_node; |
| typedef struct dom_html_options_collection dom_html_options_collection; |
| dom_exception dom_html_options_collection_get_length( |
| dom_html_options_collection *col, uint32_t *len); |
| dom_exception dom_html_options_collection_set_length( |
| dom_html_options_collection *col, uint32_t len); |
| dom_exception dom_html_options_collection_item( |
| dom_html_options_collection *col, uint32_t index, |
| struct dom_node **node); |
| dom_exception dom_html_options_collection_named_item( |
| dom_html_options_collection *col, dom_string *name, |
| struct dom_node **node); |
| void dom_html_options_collection_ref(dom_html_options_collection *col); |
| void dom_html_options_collection_unref(dom_html_options_collection *col); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_paragraph_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_param_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_pre_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_quote_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_script_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_select_element.h |
|---|
| 0,0 → 1,88 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_html_select_element_h_ |
| #define dom_html_select_element_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/html/html_form_element.h> |
| typedef struct dom_html_select_element dom_html_select_element; |
| struct dom_html_options_collection; |
| struct dom_html_element; |
| dom_exception dom_html_select_element_get_type( |
| dom_html_select_element *ele, dom_string **type); |
| dom_exception dom_html_select_element_get_selected_index( |
| dom_html_select_element *ele, int32_t *index); |
| dom_exception dom_html_select_element_set_selected_index( |
| dom_html_select_element *ele, int32_t index); |
| dom_exception dom_html_select_element_get_value( |
| dom_html_select_element *ele, dom_string **value); |
| dom_exception dom_html_select_element_set_value( |
| dom_html_select_element *ele, dom_string *value); |
| dom_exception dom_html_select_element_get_length( |
| dom_html_select_element *ele, uint32_t *len); |
| dom_exception dom_html_select_element_set_length( |
| dom_html_select_element *ele, uint32_t len); |
| dom_exception dom_html_select_element_get_form( |
| dom_html_select_element *ele, dom_html_form_element **form); |
| dom_exception dom__html_select_element_get_options( |
| dom_html_select_element *ele, |
| struct dom_html_options_collection **col); |
| #define dom_html_select_element_get_options(e, c) \ |
| dom__html_select_element_get_options((dom_html_select_element *) (e), \ |
| (struct dom_html_options_collection **) (c)) |
| dom_exception dom_html_select_element_get_disabled( |
| dom_html_select_element *ele, bool *disabled); |
| dom_exception dom_html_select_element_set_disabled( |
| dom_html_select_element *ele, bool disabled); |
| dom_exception dom_html_select_element_get_multiple( |
| dom_html_select_element *ele, bool *multiple); |
| dom_exception dom_html_select_element_set_multiple( |
| dom_html_select_element *ele, bool multiple); |
| dom_exception dom_html_select_element_get_name( |
| dom_html_select_element *ele, dom_string **name); |
| dom_exception dom_html_select_element_set_name( |
| dom_html_select_element *ele, dom_string *name); |
| dom_exception dom_html_select_element_get_size( |
| dom_html_select_element *ele, int32_t *size); |
| dom_exception dom_html_select_element_set_size( |
| dom_html_select_element *ele, int32_t size); |
| dom_exception dom_html_select_element_get_tab_index( |
| dom_html_select_element *ele, int32_t *tab_index); |
| dom_exception dom_html_select_element_set_tab_index( |
| dom_html_select_element *ele, int32_t tab_index); |
| /* Functions */ |
| dom_exception dom__html_select_element_add(dom_html_select_element *select, |
| struct dom_html_element *ele, struct dom_html_element *before); |
| #define dom_html_select_element_add(s, e, b) \ |
| dom__html_select_element_add((dom_html_select_element *) (s), \ |
| (struct dom_html_element *) (e), \ |
| (struct dom_html_element *) (b)) |
| dom_exception dom_html_select_element_remove(dom_html_select_element *ele, |
| int32_t index); |
| dom_exception dom_html_select_element_blur(struct dom_html_select_element *ele); |
| dom_exception dom_html_select_element_focus(struct dom_html_select_element *ele); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_style_element.h |
|---|
| 0,0 → 1,23 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_html_style_element_h_ |
| #define dom_html_style_element_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| typedef struct dom_html_style_element dom_html_style_element; |
| dom_exception dom_html_style_element_get_disabled(dom_html_style_element *ele, |
| bool *disabled); |
| dom_exception dom_html_style_element_set_disabled(dom_html_style_element *ele, |
| bool disabled); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_table_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_tablecaption_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_tablecell_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_tablecol_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_tablerow_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_tablesection_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/include/dom/html/html_text_area_element.h |
|---|
| 0,0 → 1,82 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #ifndef dom_html_text_area_element_h_ |
| #define dom_html_text_area_element_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| #include <dom/html/html_form_element.h> |
| typedef struct dom_html_text_area_element dom_html_text_area_element; |
| dom_exception dom_html_text_area_element_get_default_value( |
| dom_html_text_area_element *text_area, dom_string **default_value); |
| dom_exception dom_html_text_area_element_set_default_value( |
| dom_html_text_area_element *text_area, dom_string *default_value); |
| dom_exception dom_html_text_area_element_get_form( |
| dom_html_text_area_element *text_area, dom_html_form_element **form); |
| dom_exception dom_html_text_area_element_get_access_key( |
| dom_html_text_area_element *text_area, dom_string **access_key); |
| dom_exception dom_html_text_area_element_set_access_key( |
| dom_html_text_area_element *text_area, dom_string *access_key); |
| dom_exception dom_html_text_area_element_get_disabled( |
| dom_html_text_area_element *text_area, bool *disabled); |
| dom_exception dom_html_text_area_element_set_disabled( |
| dom_html_text_area_element *text_area, bool disabled); |
| dom_exception dom_html_text_area_element_get_cols( |
| dom_html_text_area_element *text_area, int32_t *cols); |
| dom_exception dom_html_text_area_element_set_cols( |
| dom_html_text_area_element *text_area, uint32_t cols); |
| dom_exception dom_html_text_area_element_get_rows( |
| dom_html_text_area_element *text_area, int32_t *rows); |
| dom_exception dom_html_text_area_element_set_rows( |
| dom_html_text_area_element *text_area, uint32_t rows); |
| dom_exception dom_html_text_area_element_get_name( |
| dom_html_text_area_element *text_area, dom_string **name); |
| dom_exception dom_html_text_area_element_set_name( |
| dom_html_text_area_element *text_area, dom_string *name); |
| dom_exception dom_html_text_area_element_get_read_only( |
| dom_html_text_area_element *text_area, bool *read_only); |
| dom_exception dom_html_text_area_element_set_read_only( |
| dom_html_text_area_element *text_area, bool read_only); |
| dom_exception dom_html_text_area_element_get_tab_index( |
| dom_html_text_area_element *text_area, int32_t *tab_index); |
| dom_exception dom_html_text_area_element_set_tab_index( |
| dom_html_text_area_element *text_area, uint32_t tab_index); |
| dom_exception dom_html_text_area_element_get_type( |
| dom_html_text_area_element *text_area, dom_string **type); |
| dom_exception dom_html_text_area_element_get_value( |
| dom_html_text_area_element *text_area, dom_string **value); |
| dom_exception dom_html_text_area_element_set_value( |
| dom_html_text_area_element *text_area, dom_string *value); |
| dom_exception dom_html_text_area_element_blur(dom_html_text_area_element *ele); |
| dom_exception dom_html_text_area_element_focus(dom_html_text_area_element *ele); |
| dom_exception dom_html_text_area_element_select(dom_html_text_area_element *ele); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_title_element.h |
|---|
| 0,0 → 1,23 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_html_title_element_h_ |
| #define dom_html_title_element_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| typedef struct dom_html_title_element dom_html_title_element; |
| dom_exception dom_html_title_element_get_text(dom_html_title_element *ele, |
| dom_string **text); |
| dom_exception dom_html_title_element_set_text(dom_html_title_element *ele, |
| dom_string *text); |
| #endif |
| /contrib/network/netsurf/libdom/include/dom/html/html_ulist_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/libdom.pc.in |
|---|
| 0,0 → 1,11 |
| prefix=PREFIX |
| exec_prefix=${prefix} |
| libdir=${exec_prefix}/lib |
| includedir=${prefix}/include |
| Name: libdom |
| Description: W3C DOM implementation |
| Version: VERSION |
| REQUIRED |
| Libs: -L${libdir} -ldom -lexpat |
| Cflags: -I${includedir} |
| /contrib/network/netsurf/libdom/src/Makefile |
|---|
| 0,0 → 1,3 |
| # Src |
| include $(NSBUILD)/Makefile.subdir |
| /contrib/network/netsurf/libdom/src/core/Makefile |
|---|
| 0,0 → 1,15 |
| # Sources |
| OBJS := \ |
| string.o node.o \ |
| attr.o characterdata.o element.o \ |
| implementation.o \ |
| text.o typeinfo.o comment.o \ |
| namednodemap.o nodelist.o \ |
| cdatasection.o document_type.o entity_ref.o pi.o \ |
| doc_fragment.o document.o |
| OUTFILE = libo.o |
| CFLAGS += -I ../../include/ -I ../../ -I ../ -I ./ -I /home/sourcerer/kos_src/newenginek/kolibri/include |
| include $(MENUETDEV)/makefiles/Makefile_for_o_lib |
| /contrib/network/netsurf/libdom/src/core/attr.c |
|---|
| 0,0 → 1,841 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stddef.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <dom/core/attr.h> |
| #include <dom/core/document.h> |
| #include <dom/core/node.h> |
| #include <dom/core/string.h> |
| #include "core/attr.h" |
| #include "core/document.h" |
| #include "core/entity_ref.h" |
| #include "core/node.h" |
| #include "core/element.h" |
| #include "utils/utils.h" |
| struct dom_element; |
| /** |
| * DOM attribute node |
| */ |
| struct dom_attr { |
| struct dom_node_internal base; /**< Base node */ |
| struct dom_type_info *schema_type_info; /**< Type information */ |
| dom_attr_type type; /**< The type of this attribute */ |
| union { |
| uint32_t lvalue; |
| unsigned short svalue; |
| bool bvalue; |
| } value; /**< The special type value of this attribute */ |
| bool specified; /**< Whether the attribute is specified or default */ |
| bool is_id; /**< Whether this attribute is a ID attribute */ |
| bool read_only; /**< Whether this attribute is readonly */ |
| }; |
| /* The vtable for dom_attr node */ |
| static struct dom_attr_vtable attr_vtable = { |
| { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE, |
| }, |
| DOM_NODE_VTABLE_ATTR |
| }, |
| DOM_ATTR_VTABLE |
| }; |
| /* The protected vtable for dom_attr */ |
| static struct dom_node_protect_vtable attr_protect_vtable = { |
| DOM_ATTR_PROTECT_VTABLE |
| }; |
| /* -------------------------------------------------------------------- */ |
| /* Constructor and destructor */ |
| /** |
| * Create an attribute node |
| * |
| * \param doc The owning document |
| * \param name The (local) name of the node to create |
| * \param namespace The namespace URI of the attribute, or NULL |
| * \param prefix The namespace prefix of the attribute, or NULL |
| * \param specified Whether this attribute is specified |
| * \param result Pointer to location to receive created attribute |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * ::doc and ::name will have their reference counts increased. The |
| * caller should make sure that ::name is a valid NCName here. |
| * |
| * The returned attribute will already be referenced. |
| */ |
| dom_exception _dom_attr_create(struct dom_document *doc, |
| dom_string *name, dom_string *namespace, |
| dom_string *prefix, bool specified, |
| struct dom_attr **result) |
| { |
| struct dom_attr *a; |
| dom_exception err; |
| /* Allocate the attribute node */ |
| a = malloc(sizeof(struct dom_attr)); |
| if (a == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Initialise the vtable */ |
| a->base.base.vtable = &attr_vtable; |
| a->base.vtable = &attr_protect_vtable; |
| /* Initialise the class */ |
| err = _dom_attr_initialise(a, doc, name, namespace, prefix, specified, |
| result); |
| if (err != DOM_NO_ERR) { |
| free(a); |
| return err; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Initialise a dom_attr |
| * |
| * \param a The dom_attr |
| * \param doc The document |
| * \param name The name of this attribute node |
| * \param namespace The namespace of this attribute |
| * \param prefix The prefix |
| * \param specified Whether this node is a specified one |
| * \param result The returned node |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_attr_initialise(dom_attr *a, |
| struct dom_document *doc, dom_string *name, |
| dom_string *namespace, dom_string *prefix, |
| bool specified, struct dom_attr **result) |
| { |
| dom_exception err; |
| err = _dom_node_initialise(&a->base, doc, DOM_ATTRIBUTE_NODE, |
| name, NULL, namespace, prefix); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| a->specified = specified; |
| a->schema_type_info = NULL; |
| a->is_id = false; |
| /* The attribute type is unset when it is created */ |
| a->type = DOM_ATTR_UNSET; |
| a->read_only = false; |
| *result = a; |
| return DOM_NO_ERR; |
| } |
| /** |
| * The destructor of dom_attr |
| * |
| * \param attr The attribute |
| */ |
| void _dom_attr_finalise(dom_attr *attr) |
| { |
| /* Now, clean up this node and destroy it */ |
| if (attr->schema_type_info != NULL) { |
| /** \todo destroy schema type info */ |
| } |
| _dom_node_finalise(&attr->base); |
| } |
| /** |
| * Destroy an attribute node |
| * |
| * \param attr The attribute to destroy |
| * |
| * The contents of ::attr will be destroyed and ::attr will be freed |
| */ |
| void _dom_attr_destroy(struct dom_attr *attr) |
| { |
| _dom_attr_finalise(attr); |
| free(attr); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Following are our implementation specific APIs */ |
| /** |
| * Get the Attr Node type |
| * |
| * \param a The attribute node |
| * \return the type |
| */ |
| dom_attr_type dom_attr_get_type(dom_attr *a) |
| { |
| return a->type; |
| } |
| /** |
| * Get the integer value of this attribute |
| * |
| * \param a The attribute object |
| * \param value The returned value |
| * \return DOM_NO_ERR on success, |
| * DOM_ATTR_WRONG_TYPE_ERR if the attribute node is not a integer |
| * attribute |
| */ |
| dom_exception dom_attr_get_integer(dom_attr *a, uint32_t *value) |
| { |
| if (a->type != DOM_ATTR_INTEGER) |
| return DOM_ATTR_WRONG_TYPE_ERR; |
| *value = a->value.lvalue; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the integer value of this attribute |
| * |
| * \param a The attribute object |
| * \param value The new value |
| * \return DOM_NO_ERR on success, |
| * DOM_ATTR_WRONG_TYPE_ERR if the attribute node is not a integer |
| * attribute |
| */ |
| dom_exception dom_attr_set_integer(dom_attr *a, uint32_t value) |
| { |
| struct dom_document *doc; |
| struct dom_node_internal *ele; |
| bool success = true; |
| dom_exception err; |
| /* If this is the first set method, we should fix this attribute |
| * type */ |
| if (a->type == DOM_ATTR_UNSET) |
| a->type = DOM_ATTR_INTEGER; |
| if (a->type != DOM_ATTR_INTEGER) |
| return DOM_ATTR_WRONG_TYPE_ERR; |
| if (a->value.lvalue == value) |
| return DOM_NO_ERR; |
| a->value.lvalue = value; |
| doc = dom_node_get_owner(a); |
| ele = dom_node_get_parent(a); |
| err = _dom_dispatch_attr_modified_event(doc, ele, NULL, NULL, |
| (dom_event_target *) a, NULL, |
| DOM_MUTATION_MODIFICATION, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(doc, |
| (dom_event_target *) a, &success); |
| return err; |
| } |
| /** |
| * Get the short value of this attribute |
| * |
| * \param a The attribute object |
| * \param value The returned value |
| * \return DOM_NO_ERR on success, |
| * DOM_ATTR_WRONG_TYPE_ERR if the attribute node is not a short |
| * attribute |
| */ |
| dom_exception dom_attr_get_short(dom_attr *a, unsigned short *value) |
| { |
| if (a->type != DOM_ATTR_SHORT) |
| return DOM_ATTR_WRONG_TYPE_ERR; |
| *value = a->value.svalue; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the short value of this attribute |
| * |
| * \param a The attribute object |
| * \param value The new value |
| * \return DOM_NO_ERR on success, |
| * DOM_ATTR_WRONG_TYPE_ERR if the attribute node is not a short |
| * attribute |
| */ |
| dom_exception dom_attr_set_short(dom_attr *a, unsigned short value) |
| { |
| struct dom_document *doc; |
| struct dom_node_internal *ele; |
| bool success = true; |
| dom_exception err; |
| /* If this is the first set method, we should fix this attribute |
| * type */ |
| if (a->type == DOM_ATTR_UNSET) |
| a->type = DOM_ATTR_SHORT; |
| if (a->type != DOM_ATTR_SHORT) |
| return DOM_ATTR_WRONG_TYPE_ERR; |
| if (a->value.svalue == value) |
| return DOM_NO_ERR; |
| a->value.svalue = value; |
| doc = dom_node_get_owner(a); |
| ele = dom_node_get_parent(a); |
| err = _dom_dispatch_attr_modified_event(doc, ele, NULL, NULL, |
| (dom_event_target *) a, NULL, |
| DOM_MUTATION_MODIFICATION, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(doc, |
| (dom_event_target *) a, &success); |
| return err; |
| } |
| /** |
| * Get the bool value of this attribute |
| * |
| * \param a The attribute object |
| * \param value The returned value |
| * \return DOM_NO_ERR on success, |
| * DOM_ATTR_WRONG_TYPE_ERR if the attribute node is not a bool |
| * attribute |
| */ |
| dom_exception dom_attr_get_bool(dom_attr *a, bool *value) |
| { |
| if (a->type != DOM_ATTR_BOOL) |
| return DOM_ATTR_WRONG_TYPE_ERR; |
| *value = a->value.bvalue; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the bool value of this attribute |
| * |
| * \param a The attribute object |
| * \param value The new value |
| * \return DOM_NO_ERR on success, |
| * DOM_ATTR_WRONG_TYPE_ERR if the attribute node is not a bool |
| * attribute |
| */ |
| dom_exception dom_attr_set_bool(dom_attr *a, bool value) |
| { |
| struct dom_document *doc; |
| struct dom_node_internal *ele; |
| bool success = true; |
| dom_exception err; |
| /* If this is the first set method, we should fix this attribute |
| * type */ |
| if (a->type == DOM_ATTR_UNSET) |
| a->type = DOM_ATTR_BOOL; |
| if (a->type != DOM_ATTR_BOOL) |
| return DOM_ATTR_WRONG_TYPE_ERR; |
| if (a->value.bvalue == value) |
| return DOM_NO_ERR; |
| a->value.bvalue = value; |
| doc = dom_node_get_owner(a); |
| ele = dom_node_get_parent(a); |
| err = _dom_dispatch_attr_modified_event(doc, ele, NULL, NULL, |
| (dom_event_target *) a, NULL, |
| DOM_MUTATION_MODIFICATION, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(doc, |
| (dom_event_target *) a, &success); |
| return err; |
| } |
| /** |
| * Set the node as a readonly attribute |
| * |
| * \param a The attribute |
| */ |
| void dom_attr_mark_readonly(dom_attr *a) |
| { |
| a->read_only = true; |
| } |
| /* -------------------------------------------------------------------- */ |
| /* The public virtual functions */ |
| /** |
| * Retrieve an attribute's name |
| * |
| * \param attr Attribute to retrieve name from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_attr_get_name(struct dom_attr *attr, |
| dom_string **result) |
| { |
| /* This is the same as nodeName */ |
| return dom_node_get_node_name(attr, result); |
| } |
| /** |
| * Determine if attribute was specified or default |
| * |
| * \param attr Attribute to inspect |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_attr_get_specified(struct dom_attr *attr, bool *result) |
| { |
| *result = attr->specified; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve an attribute's value |
| * |
| * \param attr Attribute to retrieve value from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_attr_get_value(struct dom_attr *attr, |
| dom_string **result) |
| { |
| struct dom_node_internal *a = (struct dom_node_internal *) attr; |
| struct dom_node_internal *c; |
| dom_string *value, *temp; |
| dom_exception err; |
| /* Attempt to shortcut for a single text node child with value */ |
| if ((a->first_child != NULL) && |
| (a->first_child == a->last_child) && |
| (a->first_child->type == DOM_TEXT_NODE) && |
| (a->first_child->value != NULL)) { |
| *result = dom_string_ref(a->first_child->value); |
| return DOM_NO_ERR; |
| } |
| err = dom_string_create(NULL, 0, &value); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Force unknown types to strings, if necessary */ |
| if (attr->type == DOM_ATTR_UNSET && a->first_child != NULL) { |
| attr->type = DOM_ATTR_STRING; |
| } |
| /* If this attribute node is not a string one, we just return an empty |
| * string */ |
| if (attr->type != DOM_ATTR_STRING) { |
| *result = value; |
| return DOM_NO_ERR; |
| } |
| /* Traverse children, building a string representation as we go */ |
| for (c = a->first_child; c != NULL; c = c->next) { |
| if (c->type == DOM_TEXT_NODE && c->value != NULL) { |
| /* Append to existing value */ |
| err = dom_string_concat(value, c->value, &temp); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(value); |
| return err; |
| } |
| /* Finished with previous value */ |
| dom_string_unref(value); |
| /* Claim new value */ |
| value = temp; |
| } else if (c->type == DOM_ENTITY_REFERENCE_NODE) { |
| dom_string *tr; |
| /* Get textual representation of entity */ |
| err = _dom_entity_reference_get_textual_representation( |
| (struct dom_entity_reference *) c, |
| &tr); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(value); |
| return err; |
| } |
| /* Append to existing value */ |
| err = dom_string_concat(value, tr, &temp); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(tr); |
| dom_string_unref(value); |
| return err; |
| } |
| /* No int32_ter need textual representation */ |
| dom_string_unref(tr); |
| /* Finished with previous value */ |
| dom_string_unref(value); |
| /* Claim new value */ |
| value = temp; |
| } |
| } |
| *result = value; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set an attribute's value |
| * |
| * \param attr Attribute to retrieve value from |
| * \param value New value for attribute |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if attribute is readonly. |
| */ |
| dom_exception _dom_attr_set_value(struct dom_attr *attr, |
| dom_string *value) |
| { |
| struct dom_node_internal *a = (struct dom_node_internal *) attr; |
| struct dom_node_internal *c, *d; |
| struct dom_text *text; |
| dom_exception err; |
| dom_string *name = NULL; |
| dom_string *parsed = NULL; |
| /* Ensure attribute is writable */ |
| if (_dom_node_readonly(a)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| /* If this is the first set method, we should fix this attribute |
| * type */ |
| if (attr->type == DOM_ATTR_UNSET) |
| attr->type = DOM_ATTR_STRING; |
| if (attr->type != DOM_ATTR_STRING) |
| return DOM_ATTR_WRONG_TYPE_ERR; |
| err = _dom_attr_get_name(attr, &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_element_parse_attribute(a->parent, name, value, &parsed); |
| dom_string_unref(name); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Create text node containing new value */ |
| err = dom_document_create_text_node(a->owner, parsed, &text); |
| dom_string_unref(parsed); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* Destroy children of this node */ |
| for (c = a->first_child; c != NULL; c = d) { |
| d = c->next; |
| /* Detach child */ |
| c->parent = NULL; |
| /* Detach from sibling list */ |
| c->previous = NULL; |
| c->next = NULL; |
| dom_node_try_destroy(c); |
| } |
| /* And insert the text node as the value */ |
| ((struct dom_node_internal *) text)->parent = a; |
| a->first_child = a->last_child = (struct dom_node_internal *) text; |
| dom_node_unref(text); |
| dom_node_remove_pending(text); |
| /* Now the attribute node is specified */ |
| attr->specified = true; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the owning element of an attribute |
| * |
| * \param attr The attribute to extract owning element from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. The caller |
| * should unref it once it has finished with it. |
| */ |
| dom_exception _dom_attr_get_owner(struct dom_attr *attr, |
| struct dom_element **result) |
| { |
| struct dom_node_internal *a = (struct dom_node_internal *) attr; |
| /* If there is an owning element, increase its reference count */ |
| if (a->parent != NULL) |
| dom_node_ref(a->parent); |
| *result = (struct dom_element *) a->parent; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve an attribute's type information |
| * |
| * \param attr The attribute to extract type information from |
| * \param result Pointer to location to receive result |
| * \return DOM_NOT_SUPPORTED_ERR, we don't support this API now. |
| * |
| * The returned type info will have its reference count increased. The caller |
| * should unref it once it has finished with it. |
| */ |
| dom_exception _dom_attr_get_schema_type_info(struct dom_attr *attr, |
| struct dom_type_info **result) |
| { |
| UNUSED(attr); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Determine if an attribute if of type ID |
| * |
| * \param attr The attribute to inspect |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_attr_is_id(struct dom_attr *attr, bool *result) |
| { |
| *result = attr->is_id; |
| return DOM_NO_ERR; |
| } |
| /*------------- The overload virtual functions ------------------------*/ |
| /* Overload function of Node, please refer node.c for the detail of this |
| * function. */ |
| dom_exception _dom_attr_get_node_value(dom_node_internal *node, |
| dom_string **result) |
| { |
| dom_attr *attr = (dom_attr *) node; |
| return _dom_attr_get_value(attr, result); |
| } |
| /* Overload function of Node, please refer node.c for the detail of this |
| * function. */ |
| dom_exception _dom_attr_clone_node(dom_node_internal *node, bool deep, |
| dom_node_internal **result) |
| { |
| dom_exception err; |
| dom_attr *attr; |
| /* Discard the warnings */ |
| UNUSED(deep); |
| /* Clone an Attr always clone all its children */ |
| err = _dom_node_clone_node(node, true, result); |
| if (err != DOM_NO_ERR) |
| return err; |
| attr = (dom_attr *) *result; |
| /* Clone an Attr always result a specified Attr, |
| * see DOM Level 3 Node.cloneNode */ |
| attr->specified = true; |
| return DOM_NO_ERR; |
| } |
| /* Overload function of Node, please refer node.c for the detail of this |
| * function. */ |
| dom_exception _dom_attr_set_prefix(dom_node_internal *node, |
| dom_string *prefix) |
| { |
| /* Really I don't know whether there should something |
| * special to do here */ |
| return _dom_node_set_prefix(node, prefix); |
| } |
| /* Overload function of Node, please refer node.c for the detail of this |
| * function. */ |
| dom_exception _dom_attr_lookup_prefix(dom_node_internal *node, |
| dom_string *namespace, dom_string **result) |
| { |
| struct dom_element *owner; |
| dom_exception err; |
| err = dom_attr_get_owner_element(node, &owner); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (owner == NULL) { |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| return dom_node_lookup_prefix(owner, namespace, result); |
| } |
| /* Overload function of Node, please refer node.c for the detail of this |
| * function. */ |
| dom_exception _dom_attr_is_default_namespace(dom_node_internal *node, |
| dom_string *namespace, bool *result) |
| { |
| struct dom_element *owner; |
| dom_exception err; |
| err = dom_attr_get_owner_element(node, &owner); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (owner == NULL) { |
| *result = false; |
| return DOM_NO_ERR; |
| } |
| return dom_node_is_default_namespace(owner, namespace, result); |
| } |
| /* Overload function of Node, please refer node.c for the detail of this |
| * function. */ |
| dom_exception _dom_attr_lookup_namespace(dom_node_internal *node, |
| dom_string *prefix, dom_string **result) |
| { |
| struct dom_element *owner; |
| dom_exception err; |
| err = dom_attr_get_owner_element(node, &owner); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (owner == NULL) { |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| return dom_node_lookup_namespace(owner, prefix, result); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual destroy function of this class */ |
| void __dom_attr_destroy(dom_node_internal *node) |
| { |
| _dom_attr_destroy((dom_attr *) node); |
| } |
| /* The memory allocator of this class */ |
| dom_exception _dom_attr_copy(dom_node_internal *n, dom_node_internal **copy) |
| { |
| dom_attr *old = (dom_attr *) n; |
| dom_attr *a; |
| dom_exception err; |
| a = malloc(sizeof(struct dom_attr)); |
| if (a == NULL) |
| return DOM_NO_MEM_ERR; |
| err = dom_node_copy_internal(n, a); |
| if (err != DOM_NO_ERR) { |
| free(a); |
| return err; |
| } |
| a->specified = old->specified; |
| /* TODO: deal with dom_type_info, it get no definition ! */ |
| a->schema_type_info = NULL; |
| a->is_id = old->is_id; |
| a->type = old->type; |
| a->value = old->value; |
| /* TODO: is this correct? */ |
| a->read_only = false; |
| *copy = (dom_node_internal *) a; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set/Unset whether this attribute is a ID attribute |
| * |
| * \param attr The attribute |
| * \param is_id Whether it is a ID attribute |
| */ |
| void _dom_attr_set_isid(struct dom_attr *attr, bool is_id) |
| { |
| attr->is_id = is_id; |
| } |
| /** |
| * Set/Unset whether the attribute is a specified one. |
| * |
| * \param attr The attribute node |
| * \param specified Whether this attribute is a specified one |
| */ |
| void _dom_attr_set_specified(struct dom_attr *attr, bool specified) |
| { |
| attr->specified = specified; |
| } |
| /** |
| * Whether this attribute node is readonly |
| * |
| * \param a The node |
| * \return true if this Attr is readonly, false otherwise |
| */ |
| bool _dom_attr_readonly(const dom_attr *a) |
| { |
| return a->read_only; |
| } |
| /contrib/network/netsurf/libdom/src/core/attr.h |
|---|
| 0,0 → 1,118 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_attr_h_ |
| #define dom_internal_core_attr_h_ |
| #include <dom/core/attr.h> |
| struct dom_document; |
| struct dom_type_info; |
| dom_exception _dom_attr_create(struct dom_document *doc, |
| dom_string *name, dom_string *namespace, |
| dom_string *prefix, bool specified, |
| struct dom_attr **result); |
| void _dom_attr_destroy(struct dom_attr *attr); |
| dom_exception _dom_attr_initialise(struct dom_attr *a, |
| struct dom_document *doc, dom_string *name, |
| dom_string *namespace, dom_string *prefix, |
| bool specified, struct dom_attr **result); |
| void _dom_attr_finalise(struct dom_attr *attr); |
| /* Virtual functions for dom_attr */ |
| dom_exception _dom_attr_get_name(struct dom_attr *attr, |
| dom_string **result); |
| dom_exception _dom_attr_get_specified(struct dom_attr *attr, bool *result); |
| dom_exception _dom_attr_get_value(struct dom_attr *attr, |
| dom_string **result); |
| dom_exception _dom_attr_set_value(struct dom_attr *attr, |
| dom_string *value); |
| dom_exception _dom_attr_get_owner(struct dom_attr *attr, |
| struct dom_element **result); |
| dom_exception _dom_attr_get_schema_type_info(struct dom_attr *attr, |
| struct dom_type_info **result); |
| dom_exception _dom_attr_is_id(struct dom_attr *attr, bool *result); |
| #define DOM_ATTR_VTABLE \ |
| _dom_attr_get_name, \ |
| _dom_attr_get_specified, \ |
| _dom_attr_get_value, \ |
| _dom_attr_set_value, \ |
| _dom_attr_get_owner, \ |
| _dom_attr_get_schema_type_info, \ |
| _dom_attr_is_id |
| /* Overloading dom_node functions */ |
| dom_exception _dom_attr_get_node_value(dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_attr_clone_node(dom_node_internal *node, bool deep, |
| dom_node_internal **result); |
| dom_exception _dom_attr_set_prefix(dom_node_internal *node, |
| dom_string *prefix); |
| dom_exception _dom_attr_normalize(dom_node_internal *node); |
| dom_exception _dom_attr_lookup_prefix(dom_node_internal *node, |
| dom_string *namespace, dom_string **result); |
| dom_exception _dom_attr_is_default_namespace(dom_node_internal *node, |
| dom_string *namespace, bool *result); |
| dom_exception _dom_attr_lookup_namespace(dom_node_internal *node, |
| dom_string *prefix, dom_string **result); |
| #define DOM_NODE_VTABLE_ATTR \ |
| _dom_node_try_destroy, \ |
| _dom_node_get_node_name, \ |
| _dom_attr_get_node_value, /*overload*/\ |
| _dom_node_set_node_value, \ |
| _dom_node_get_node_type, \ |
| _dom_node_get_parent_node, \ |
| _dom_node_get_child_nodes, \ |
| _dom_node_get_first_child, \ |
| _dom_node_get_last_child, \ |
| _dom_node_get_previous_sibling, \ |
| _dom_node_get_next_sibling, \ |
| _dom_node_get_attributes, \ |
| _dom_node_get_owner_document, \ |
| _dom_node_insert_before, \ |
| _dom_node_replace_child, \ |
| _dom_node_remove_child, \ |
| _dom_node_append_child, \ |
| _dom_node_has_child_nodes, \ |
| _dom_attr_clone_node, /*overload*/\ |
| _dom_node_normalize, \ |
| _dom_node_is_supported, \ |
| _dom_node_get_namespace, \ |
| _dom_node_get_prefix, \ |
| _dom_attr_set_prefix, /*overload*/\ |
| _dom_node_get_local_name, \ |
| _dom_node_has_attributes, \ |
| _dom_node_get_base, \ |
| _dom_node_compare_document_position, \ |
| _dom_node_get_text_content, \ |
| _dom_node_set_text_content, \ |
| _dom_node_is_same, \ |
| _dom_attr_lookup_prefix, /*overload*/\ |
| _dom_attr_is_default_namespace, /*overload*/\ |
| _dom_attr_lookup_namespace, /*overload*/\ |
| _dom_node_is_equal, \ |
| _dom_node_get_feature, \ |
| _dom_node_set_user_data, \ |
| _dom_node_get_user_data |
| /* The protected virtual functions */ |
| void __dom_attr_destroy(dom_node_internal *node); |
| dom_exception _dom_attr_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_ATTR_PROTECT_VTABLE \ |
| __dom_attr_destroy, \ |
| _dom_attr_copy |
| void _dom_attr_set_isid(struct dom_attr *attr, bool is_id); |
| void _dom_attr_set_specified(struct dom_attr *attr, bool specified); |
| bool _dom_attr_readonly(const dom_attr *a); |
| #endif |
| /contrib/network/netsurf/libdom/src/core/cdatasection.c |
|---|
| 0,0 → 1,117 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "core/cdatasection.h" |
| #include "core/document.h" |
| #include "core/text.h" |
| #include "utils/utils.h" |
| /** |
| * A DOM CDATA section |
| */ |
| struct dom_cdata_section { |
| dom_text base; /**< Base node */ |
| }; |
| static struct dom_node_protect_vtable cdata_section_protect_vtable = { |
| DOM_CDATA_SECTION_PROTECT_VTABLE |
| }; |
| /** |
| * Create a CDATA section |
| * |
| * \param doc The owning document |
| * \param name The name of the node to create |
| * \param value The text content of the node |
| * \param result Pointer to location to receive created node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * ::doc, ::name and ::value will have their reference counts increased. |
| * |
| * The returned node will already be referenced. |
| */ |
| dom_exception _dom_cdata_section_create(dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_cdata_section **result) |
| { |
| dom_cdata_section *c; |
| dom_exception err; |
| /* Allocate the comment node */ |
| c = malloc(sizeof(dom_cdata_section)); |
| if (c == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtable */ |
| ((dom_node_internal *) c)->base.vtable = &text_vtable; |
| ((dom_node_internal *) c)->vtable = &cdata_section_protect_vtable; |
| /* And initialise the node */ |
| err = _dom_cdata_section_initialise(&c->base, doc, |
| DOM_CDATA_SECTION_NODE, name, value); |
| if (err != DOM_NO_ERR) { |
| free(c); |
| return err; |
| } |
| *result = c; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Destroy a CDATA section |
| * |
| * \param cdata The cdata section to destroy |
| * |
| * The contents of ::cdata will be destroyed and ::cdata will be freed. |
| */ |
| void _dom_cdata_section_destroy(dom_cdata_section *cdata) |
| { |
| /* Clean up base node contents */ |
| _dom_cdata_section_finalise(&cdata->base); |
| /* Destroy the node */ |
| free(cdata); |
| } |
| /*--------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual destroy function of this class */ |
| void __dom_cdata_section_destroy(dom_node_internal *node) |
| { |
| _dom_cdata_section_destroy((dom_cdata_section *) node); |
| } |
| /* The copy constructor of this class */ |
| dom_exception _dom_cdata_section_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| dom_cdata_section *new_cdata; |
| dom_exception err; |
| new_cdata = malloc(sizeof(dom_cdata_section)); |
| if (new_cdata == NULL) |
| return DOM_NO_MEM_ERR; |
| err = dom_text_copy_internal(old, new_cdata); |
| if (err != DOM_NO_ERR) { |
| free(new_cdata); |
| return err; |
| } |
| *copy = (dom_node_internal *) new_cdata; |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/core/cdatasection.h |
|---|
| 0,0 → 1,36 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_cdatasection_h_ |
| #define dom_internal_core_cdatasection_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/cdatasection.h> |
| #include <dom/core/string.h> |
| struct dom_node_internal; |
| struct dom_document; |
| dom_exception _dom_cdata_section_create(struct dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_cdata_section **result); |
| void _dom_cdata_section_destroy(dom_cdata_section *cdata); |
| #define _dom_cdata_section_initialise _dom_text_initialise |
| #define _dom_cdata_section_finalise _dom_text_finalise |
| /* Following comes the protected vtable */ |
| void __dom_cdata_section_destroy(struct dom_node_internal *node); |
| dom_exception _dom_cdata_section_copy(struct dom_node_internal *old, |
| struct dom_node_internal **copy); |
| #define DOM_CDATA_SECTION_PROTECT_VTABLE \ |
| __dom_cdata_section_destroy, \ |
| _dom_cdata_section_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/core/characterdata.c |
|---|
| 0,0 → 1,513 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/core/characterdata.h> |
| #include <dom/core/string.h> |
| #include <dom/events/events.h> |
| #include "core/characterdata.h" |
| #include "core/document.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| #include "events/mutation_event.h" |
| /* The virtual functions for dom_characterdata, we make this vtable |
| * public to each child class */ |
| struct dom_characterdata_vtable characterdata_vtable = { |
| { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE |
| }, |
| DOM_NODE_VTABLE_CHARACTERDATA |
| }, |
| DOM_CHARACTERDATA_VTABLE |
| }; |
| /* Create a DOM characterdata node and compose the vtable */ |
| dom_characterdata *_dom_characterdata_create(void) |
| { |
| dom_characterdata *cdata = malloc(sizeof(struct dom_characterdata)); |
| if (cdata == NULL) |
| return NULL; |
| cdata->base.base.vtable = &characterdata_vtable; |
| cdata->base.vtable = NULL; |
| return cdata; |
| } |
| /** |
| * Initialise a character data node |
| * |
| * \param node The node to initialise |
| * \param doc The document which owns the node |
| * \param type The node type required |
| * \param name The node name, or NULL |
| * \param value The node value, or NULL |
| * \return DOM_NO_ERR on success. |
| * |
| * ::doc, ::name and ::value will have their reference counts increased. |
| */ |
| dom_exception _dom_characterdata_initialise(struct dom_characterdata *cdata, |
| struct dom_document *doc, dom_node_type type, |
| dom_string *name, dom_string *value) |
| { |
| return _dom_node_initialise(&cdata->base, doc, type, |
| name, value, NULL, NULL); |
| } |
| /** |
| * Finalise a character data node |
| * |
| * \param cdata The node to finalise |
| * |
| * The contents of ::cdata will be cleaned up. ::cdata will not be freed. |
| */ |
| void _dom_characterdata_finalise(struct dom_characterdata *cdata) |
| { |
| _dom_node_finalise(&cdata->base); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public virtual functions */ |
| /** |
| * Retrieve data from a character data node |
| * |
| * \param cdata Character data node to retrieve data from |
| * \param data Pointer to location to receive data |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| * |
| * DOM3Core states that this can raise DOMSTRING_SIZE_ERR. It will not in |
| * this implementation; dom_strings are unbounded. |
| */ |
| dom_exception _dom_characterdata_get_data(struct dom_characterdata *cdata, |
| dom_string **data) |
| { |
| struct dom_node_internal *c = (struct dom_node_internal *) cdata; |
| if (c->value != NULL) { |
| dom_string_ref(c->value); |
| } |
| *data = c->value; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the content of a character data node |
| * |
| * \param cdata Node to set the content of |
| * \param data New value for node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::cdata is readonly. |
| * |
| * The new content will have its reference count increased, so the caller |
| * should unref it after the call (as the caller should have already claimed |
| * a reference on the string). The node's existing content will be unrefed. |
| */ |
| dom_exception _dom_characterdata_set_data(struct dom_characterdata *cdata, |
| dom_string *data) |
| { |
| struct dom_node_internal *c = (struct dom_node_internal *) cdata; |
| dom_exception err; |
| struct dom_document *doc; |
| bool success = true; |
| if (_dom_node_readonly(c)) { |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| } |
| /* Dispatch a DOMCharacterDataModified event */ |
| doc = dom_node_get_owner(cdata); |
| err = _dom_dispatch_characterdata_modified_event(doc, c, c->value, |
| data, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (c->value != NULL) { |
| dom_string_unref(c->value); |
| } |
| dom_string_ref(data); |
| c->value = data; |
| success = true; |
| return _dom_dispatch_subtree_modified_event(doc, c->parent, &success); |
| } |
| /** |
| * Get the length (in characters) of a character data node's content |
| * |
| * \param cdata Node to read content length of |
| * \param length Pointer to location to receive character length of content |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_characterdata_get_length(struct dom_characterdata *cdata, |
| uint32_t *length) |
| { |
| struct dom_node_internal *c = (struct dom_node_internal *) cdata; |
| if (c->value != NULL) { |
| *length = dom_string_length(c->value); |
| } else { |
| *length = 0; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Extract a range of data from a character data node |
| * |
| * \param cdata The node to extract data from |
| * \param offset The character offset of substring to extract |
| * \param count The number of characters to extract |
| * \param data Pointer to location to receive substring |
| * \return DOM_NO_ERR on success, |
| * DOM_INDEX_SIZE_ERR if ::offset is negative or greater than the |
| * number of characters in ::cdata or |
| * ::count is negative. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| * |
| * DOM3Core states that this can raise DOMSTRING_SIZE_ERR. It will not in |
| * this implementation; dom_strings are unbounded. |
| */ |
| dom_exception _dom_characterdata_substring_data( |
| struct dom_characterdata *cdata, uint32_t offset, |
| uint32_t count, dom_string **data) |
| { |
| struct dom_node_internal *c = (struct dom_node_internal *) cdata; |
| uint32_t len, end; |
| if ((int32_t) offset < 0 || (int32_t) count < 0) { |
| return DOM_INDEX_SIZE_ERR; |
| } |
| if (c->value != NULL) { |
| len = dom_string_length(c->value); |
| } else { |
| len = 0; |
| } |
| if (offset > len) { |
| return DOM_INDEX_SIZE_ERR; |
| } |
| end = (offset + count) >= len ? len : offset + count; |
| return dom_string_substr(c->value, offset, end, data); |
| } |
| /** |
| * Append data to the end of a character data node's content |
| * |
| * \param cdata The node to append data to |
| * \param data The data to append |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::cdata is readonly. |
| */ |
| dom_exception _dom_characterdata_append_data(struct dom_characterdata *cdata, |
| dom_string *data) |
| { |
| struct dom_node_internal *c = (struct dom_node_internal *) cdata; |
| dom_string *temp; |
| dom_exception err; |
| struct dom_document *doc; |
| bool success = true; |
| if (_dom_node_readonly(c)) { |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| } |
| err = dom_string_concat(c->value, data, &temp); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Dispatch a DOMCharacterDataModified event */ |
| doc = dom_node_get_owner(cdata); |
| err = _dom_dispatch_characterdata_modified_event(doc, c, c->value, |
| temp, &success); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(temp); |
| return err; |
| } |
| if (c->value != NULL) { |
| dom_string_unref(c->value); |
| } |
| c->value = temp; |
| success = true; |
| return _dom_dispatch_subtree_modified_event(doc, c->parent, &success); |
| } |
| /** |
| * Insert data into a character data node's content |
| * |
| * \param cdata The node to insert into |
| * \param offset The character offset to insert at |
| * \param data The data to insert |
| * \return DOM_NO_ERR on success, |
| * DOM_INDEX_SIZE_ERR if ::offset is negative or greater |
| * than the number of characters in |
| * ::cdata, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::cdata is readonly. |
| */ |
| dom_exception _dom_characterdata_insert_data(struct dom_characterdata *cdata, |
| uint32_t offset, dom_string *data) |
| { |
| struct dom_node_internal *c = (struct dom_node_internal *) cdata; |
| dom_string *temp; |
| uint32_t len; |
| dom_exception err; |
| struct dom_document *doc; |
| bool success = true; |
| if (_dom_node_readonly(c)) { |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| } |
| if ((int32_t) offset < 0) { |
| return DOM_INDEX_SIZE_ERR; |
| } |
| if (c->value != NULL) { |
| len = dom_string_length(c->value); |
| } else { |
| len = 0; |
| } |
| if (offset > len) { |
| return DOM_INDEX_SIZE_ERR; |
| } |
| err = dom_string_insert(c->value, data, offset, &temp); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Dispatch a DOMCharacterDataModified event */ |
| doc = dom_node_get_owner(cdata); |
| err = _dom_dispatch_characterdata_modified_event(doc, c, c->value, |
| temp, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (c->value != NULL) { |
| dom_string_unref(c->value); |
| } |
| c->value = temp; |
| success = true; |
| return _dom_dispatch_subtree_modified_event(doc, c->parent, &success); |
| } |
| /** |
| * Delete data from a character data node's content |
| * |
| * \param cdata The node to delete from |
| * \param offset The character offset to start deletion from |
| * \param count The number of characters to delete |
| * \return DOM_NO_ERR on success, |
| * DOM_INDEX_SIZE_ERR if ::offset is negative or greater |
| * than the number of characters in |
| * ::cdata or ::count is negative, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::cdata is readonly. |
| */ |
| dom_exception _dom_characterdata_delete_data(struct dom_characterdata *cdata, |
| uint32_t offset, uint32_t count) |
| { |
| struct dom_node_internal *c = (struct dom_node_internal *) cdata; |
| dom_string *temp; |
| uint32_t len, end; |
| dom_exception err; |
| struct dom_document *doc; |
| bool success = true; |
| dom_string *empty; |
| if (_dom_node_readonly(c)) { |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| } |
| if ((int32_t) offset < 0 || (int32_t) count < 0) { |
| return DOM_INDEX_SIZE_ERR; |
| } |
| if (c->value != NULL) { |
| len = dom_string_length(c->value); |
| } else { |
| len = 0; |
| } |
| if (offset > len) { |
| return DOM_INDEX_SIZE_ERR; |
| } |
| end = (offset + count) >= len ? len : offset + count; |
| empty = ((struct dom_document *) |
| ((struct dom_node_internal *)c)->owner)->_memo_empty; |
| err = dom_string_replace(c->value, empty, offset, end, &temp); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Dispatch a DOMCharacterDataModified event */ |
| doc = dom_node_get_owner(cdata); |
| err = _dom_dispatch_characterdata_modified_event(doc, c, c->value, |
| temp, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (c->value != NULL) { |
| dom_string_unref(c->value); |
| } |
| c->value = temp; |
| success = true; |
| return _dom_dispatch_subtree_modified_event(doc, c->parent, &success); |
| } |
| /** |
| * Replace a section of a character data node's content |
| * |
| * \param cdata The node to modify |
| * \param offset The character offset of the sequence to replace |
| * \param count The number of characters to replace |
| * \param data The replacement data |
| * \return DOM_NO_ERR on success, |
| * DOM_INDEX_SIZE_ERR if ::offset is negative or greater |
| * than the number of characters in |
| * ::cdata or ::count is negative, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::cdata is readonly. |
| */ |
| dom_exception _dom_characterdata_replace_data(struct dom_characterdata *cdata, |
| uint32_t offset, uint32_t count, |
| dom_string *data) |
| { |
| struct dom_node_internal *c = (struct dom_node_internal *) cdata; |
| dom_string *temp; |
| uint32_t len, end; |
| dom_exception err; |
| struct dom_document *doc; |
| bool success = true; |
| if (_dom_node_readonly(c)) { |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| } |
| if ((int32_t) offset < 0 || (int32_t) count < 0) { |
| return DOM_INDEX_SIZE_ERR; |
| } |
| if (c->value != NULL) { |
| len = dom_string_length(c->value); |
| } else { |
| len = 0; |
| } |
| if (offset > len) { |
| return DOM_INDEX_SIZE_ERR; |
| } |
| end = (offset + count) >= len ? len : offset + count; |
| err = dom_string_replace(c->value, data, offset, end, &temp); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Dispatch a DOMCharacterDataModified event */ |
| doc = dom_node_get_owner(cdata); |
| err = _dom_dispatch_characterdata_modified_event(doc, c, c->value, temp, |
| &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (c->value != NULL) { |
| dom_string_unref(c->value); |
| } |
| c->value = temp; |
| success = true; |
| return _dom_dispatch_subtree_modified_event(doc, c->parent, &success); |
| } |
| dom_exception _dom_characterdata_get_text_content(dom_node_internal *node, |
| dom_string **result) |
| { |
| dom_characterdata *cdata = (dom_characterdata *)node; |
| return dom_characterdata_get_data(cdata, result); |
| } |
| dom_exception _dom_characterdata_set_text_content(dom_node_internal *node, |
| dom_string *content) |
| { |
| dom_characterdata *cdata = (dom_characterdata *)node; |
| return dom_characterdata_set_data(cdata, content); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The protected virtual functions of Node, see core/node.h for details */ |
| void _dom_characterdata_destroy(struct dom_node_internal *node) |
| { |
| assert("Should never be here" == NULL); |
| UNUSED(node); |
| } |
| /* The copy constructor of this class */ |
| dom_exception _dom_characterdata_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| dom_characterdata *new_node; |
| dom_exception err; |
| new_node = malloc(sizeof(dom_characterdata)); |
| if (new_node == NULL) |
| return DOM_NO_MEM_ERR; |
| err = dom_characterdata_copy_internal(old, new_node); |
| if (err != DOM_NO_ERR) { |
| free(new_node); |
| return err; |
| } |
| *copy = (dom_node_internal *) new_node; |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_characterdata_copy_internal(dom_characterdata *old, |
| dom_characterdata *new) |
| { |
| return dom_node_copy_internal(old, new); |
| } |
| /contrib/network/netsurf/libdom/src/core/characterdata.h |
|---|
| 0,0 → 1,127 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_characterdata_h_ |
| #define dom_internal_core_characterdata_h_ |
| #include <dom/core/characterdata.h> |
| #include "core/node.h" |
| /** |
| * DOM character data node |
| */ |
| struct dom_characterdata { |
| struct dom_node_internal base; /**< Base node */ |
| }; |
| /* The CharacterData is a intermediate node type, so the following function |
| * may never be used */ |
| dom_characterdata *_dom_characterdata_create(void); |
| dom_exception _dom_characterdata_initialise(struct dom_characterdata *cdata, |
| struct dom_document *doc, dom_node_type type, |
| dom_string *name, dom_string *value); |
| void _dom_characterdata_finalise(struct dom_characterdata *cdata); |
| /* The virtual functions for dom_characterdata */ |
| dom_exception _dom_characterdata_get_data(struct dom_characterdata *cdata, |
| dom_string **data); |
| dom_exception _dom_characterdata_set_data(struct dom_characterdata *cdata, |
| dom_string *data); |
| dom_exception _dom_characterdata_get_length(struct dom_characterdata *cdata, |
| uint32_t *length); |
| dom_exception _dom_characterdata_substring_data( |
| struct dom_characterdata *cdata, uint32_t offset, |
| uint32_t count, dom_string **data); |
| dom_exception _dom_characterdata_append_data(struct dom_characterdata *cdata, |
| dom_string *data); |
| dom_exception _dom_characterdata_insert_data(struct dom_characterdata *cdata, |
| uint32_t offset, dom_string *data); |
| dom_exception _dom_characterdata_delete_data(struct dom_characterdata *cdata, |
| uint32_t offset, uint32_t count); |
| dom_exception _dom_characterdata_replace_data(struct dom_characterdata *cdata, |
| uint32_t offset, uint32_t count, |
| dom_string *data); |
| dom_exception _dom_characterdata_get_text_content( |
| dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_characterdata_set_text_content( |
| dom_node_internal *node, |
| dom_string *content); |
| #define DOM_CHARACTERDATA_VTABLE \ |
| _dom_characterdata_get_data, \ |
| _dom_characterdata_set_data, \ |
| _dom_characterdata_get_length, \ |
| _dom_characterdata_substring_data, \ |
| _dom_characterdata_append_data, \ |
| _dom_characterdata_insert_data, \ |
| _dom_characterdata_delete_data, \ |
| _dom_characterdata_replace_data |
| #define DOM_NODE_VTABLE_CHARACTERDATA \ |
| _dom_node_try_destroy, \ |
| _dom_node_get_node_name, \ |
| _dom_node_get_node_value, \ |
| _dom_node_set_node_value, \ |
| _dom_node_get_node_type, \ |
| _dom_node_get_parent_node, \ |
| _dom_node_get_child_nodes, \ |
| _dom_node_get_first_child, \ |
| _dom_node_get_last_child, \ |
| _dom_node_get_previous_sibling, \ |
| _dom_node_get_next_sibling, \ |
| _dom_node_get_attributes, \ |
| _dom_node_get_owner_document, \ |
| _dom_node_insert_before, \ |
| _dom_node_replace_child, \ |
| _dom_node_remove_child, \ |
| _dom_node_append_child, \ |
| _dom_node_has_child_nodes, \ |
| _dom_node_clone_node, \ |
| _dom_node_normalize, \ |
| _dom_node_is_supported, \ |
| _dom_node_get_namespace, \ |
| _dom_node_get_prefix, \ |
| _dom_node_set_prefix, \ |
| _dom_node_get_local_name, \ |
| _dom_node_has_attributes, \ |
| _dom_node_get_base, \ |
| _dom_node_compare_document_position, \ |
| _dom_characterdata_get_text_content, /* override */ \ |
| _dom_characterdata_set_text_content, /* override */ \ |
| _dom_node_is_same, \ |
| _dom_node_lookup_prefix, \ |
| _dom_node_is_default_namespace, \ |
| _dom_node_lookup_namespace, \ |
| _dom_node_is_equal, \ |
| _dom_node_get_feature, \ |
| _dom_node_set_user_data, \ |
| _dom_node_get_user_data |
| /* Following comes the protected vtable |
| * |
| * Only the _copy function can be used by sub-class of this. |
| */ |
| void _dom_characterdata_destroy(dom_node_internal *node); |
| dom_exception _dom_characterdata_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_CHARACTERDATA_PROTECT_VTABLE \ |
| _dom_characterdata_destroy, \ |
| _dom_characterdata_copy |
| extern struct dom_characterdata_vtable characterdata_vtable; |
| dom_exception _dom_characterdata_copy_internal(dom_characterdata *old, |
| dom_characterdata *new); |
| #define dom_characterdata_copy_internal(o, n) \ |
| _dom_characterdata_copy_internal( \ |
| (dom_characterdata *) (o), (dom_characterdata *) (n)) |
| #endif |
| /contrib/network/netsurf/libdom/src/core/comment.c |
|---|
| 0,0 → 1,118 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "core/characterdata.h" |
| #include "core/comment.h" |
| #include "core/document.h" |
| #include "utils/utils.h" |
| /** |
| * A DOM Comment node |
| */ |
| struct dom_comment { |
| dom_characterdata base; /**< Base node */ |
| }; |
| static struct dom_node_protect_vtable comment_protect_vtable = { |
| DOM_COMMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a comment node |
| * |
| * \param doc The owning document |
| * \param name The name of the node to create |
| * \param value The text content of the node |
| * \param result Pointer to location to receive created node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * ::doc, ::name and ::value will have their reference counts increased. |
| * |
| * The returned node will already be referenced. |
| */ |
| dom_exception _dom_comment_create(dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_comment **result) |
| { |
| dom_comment *c; |
| dom_exception err; |
| /* Allocate the comment node */ |
| c = malloc(sizeof(dom_comment)); |
| if (c == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set the virtual table */ |
| ((dom_node_internal *) c)->base.vtable = &characterdata_vtable; |
| ((dom_node_internal *) c)->vtable = &comment_protect_vtable; |
| /* And initialise the node */ |
| err = _dom_characterdata_initialise(&c->base, doc, DOM_COMMENT_NODE, |
| name, value); |
| if (err != DOM_NO_ERR) { |
| free(c); |
| return err; |
| } |
| *result = c; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Destroy a comment node |
| * |
| * \param comment The node to destroy |
| * |
| * The contents of ::comment will be destroyed and ::comment will be freed |
| */ |
| void _dom_comment_destroy(dom_comment *comment) |
| { |
| /* Finalise base class contents */ |
| _dom_characterdata_finalise(&comment->base); |
| /* Free node */ |
| free(comment); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual destroy function */ |
| void __dom_comment_destroy(dom_node_internal *node) |
| { |
| _dom_comment_destroy((dom_comment *) node); |
| } |
| /* The copy constructor of this class */ |
| dom_exception _dom_comment_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| dom_comment *new_comment; |
| dom_exception err; |
| new_comment = malloc(sizeof(dom_comment)); |
| if (new_comment == NULL) |
| return DOM_NO_MEM_ERR; |
| err = dom_characterdata_copy_internal(old, new_comment); |
| if (err != DOM_NO_ERR) { |
| free(new_comment); |
| return err; |
| } |
| *copy = (dom_node_internal *) new_comment; |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/core/comment.h |
|---|
| 0,0 → 1,35 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_comment_h_ |
| #define dom_internal_core_comment_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/comment.h> |
| struct dom_comment; |
| struct dom_document; |
| dom_exception _dom_comment_create(struct dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_comment **result); |
| #define _dom_comment_initialise _dom_characterdata_initialise |
| #define _dom_comment_finalise _dom_characterdata_finalise |
| void _dom_comment_destroy(dom_comment *comment); |
| /* Following comes the protected vtable */ |
| void __dom_comment_destroy(dom_node_internal *node); |
| dom_exception _dom_comment_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_COMMENT_PROTECT_VTABLE \ |
| __dom_comment_destroy, \ |
| _dom_comment_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/core/doc_fragment.c |
|---|
| 0,0 → 1,123 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include <dom/core/node.h> |
| #include "core/document.h" |
| #include "core/doc_fragment.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| /** |
| * A DOM document fragment |
| */ |
| struct dom_document_fragment { |
| dom_node_internal base; /**< Base node */ |
| }; |
| static struct dom_node_vtable df_vtable = { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE |
| }, |
| DOM_NODE_VTABLE |
| }; |
| static struct dom_node_protect_vtable df_protect_vtable = { |
| DOM_DF_PROTECT_VTABLE |
| }; |
| /** |
| * Create a document fragment |
| * |
| * \param doc The owning document |
| * \param name The name of the node to create |
| * \param value The text content of the node |
| * \param result Pointer to location to receive created node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * ::doc, ::name and ::value will have their reference counts increased. |
| * |
| * The returned node will already be referenced. |
| */ |
| dom_exception _dom_document_fragment_create(dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_document_fragment **result) |
| { |
| dom_document_fragment *f; |
| dom_exception err; |
| f = malloc(sizeof(dom_document_fragment)); |
| if (f == NULL) |
| return DOM_NO_MEM_ERR; |
| f->base.base.vtable = &df_vtable; |
| f->base.vtable = &df_protect_vtable; |
| /* And initialise the node */ |
| err = _dom_document_fragment_initialise(&f->base, doc, |
| DOM_DOCUMENT_FRAGMENT_NODE, name, value, NULL, NULL); |
| if (err != DOM_NO_ERR) { |
| free(f); |
| return err; |
| } |
| *result = f; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Destroy a document fragment |
| * |
| * \param frag The document fragment to destroy |
| * |
| * The contents of ::frag will be destroyed and ::frag will be freed. |
| */ |
| void _dom_document_fragment_destroy(dom_document_fragment *frag) |
| { |
| /* Finalise base class */ |
| _dom_document_fragment_finalise(&frag->base); |
| /* Destroy fragment */ |
| free(frag); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Overload protected functions */ |
| /* The virtual destroy function of this class */ |
| void _dom_df_destroy(dom_node_internal *node) |
| { |
| _dom_document_fragment_destroy((dom_document_fragment *) node); |
| } |
| /* The copy constructor of this class */ |
| dom_exception _dom_df_copy(dom_node_internal *old, dom_node_internal **copy) |
| { |
| dom_document_fragment *new_f; |
| dom_exception err; |
| new_f = malloc(sizeof(dom_document_fragment)); |
| if (new_f == NULL) |
| return DOM_NO_MEM_ERR; |
| err = dom_node_copy_internal(old, new_f); |
| if (err != DOM_NO_ERR) { |
| free(new_f); |
| return err; |
| } |
| *copy = (dom_node_internal *) new_f; |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/core/doc_fragment.h |
|---|
| 0,0 → 1,32 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_documentfragment_h_ |
| #define dom_internal_core_documentfragment_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/doc_fragment.h> |
| dom_exception _dom_document_fragment_create(dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_document_fragment **result); |
| void _dom_document_fragment_destroy(dom_document_fragment *frag); |
| #define _dom_document_fragment_initialise _dom_node_initialise |
| #define _dom_document_fragment_finalise _dom_node_finalise |
| /* Following comes the protected vtable */ |
| void _dom_df_destroy(dom_node_internal *node); |
| dom_exception _dom_df_copy(dom_node_internal *old, dom_node_internal **copy); |
| #define DOM_DF_PROTECT_VTABLE \ |
| _dom_df_destroy, \ |
| _dom_df_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/core/document.c |
|---|
| 0,0 → 1,1523 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| typedef signed char int8_t; |
| typedef signed short int16_t; |
| typedef signed int int32_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short uint16_t; |
| typedef unsigned int uint32_t; |
| #include <dom/functypes.h> |
| #include <dom/core/attr.h> |
| #include <dom/core/element.h> |
| #include <dom/core/document.h> |
| #include <dom/core/implementation.h> |
| #include "core/string.h" |
| #include "core/attr.h" |
| #include "core/cdatasection.h" |
| #include "core/comment.h" |
| #include "core/document.h" |
| #include "core/doc_fragment.h" |
| #include "core/element.h" |
| #include "core/entity_ref.h" |
| #include "core/namednodemap.h" |
| #include "core/nodelist.h" |
| #include "core/pi.h" |
| #include "core/text.h" |
| #include "utils/validate.h" |
| #include "utils/namespace.h" |
| #include "utils/utils.h" |
| /** |
| * Item in list of active nodelists |
| */ |
| struct dom_doc_nl { |
| dom_nodelist *list; /**< Nodelist */ |
| struct dom_doc_nl *next; /**< Next item */ |
| struct dom_doc_nl *prev; /**< Previous item */ |
| }; |
| /* The virtual functions of this dom_document */ |
| static struct dom_document_vtable document_vtable = { |
| { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE |
| }, |
| DOM_NODE_VTABLE_DOCUMENT |
| }, |
| DOM_DOCUMENT_VTABLE |
| }; |
| static struct dom_node_protect_vtable document_protect_vtable = { |
| DOM_DOCUMENT_PROTECT_VTABLE |
| }; |
| /*----------------------------------------------------------------------*/ |
| /* Internally used helper functions */ |
| static dom_exception dom_document_dup_node(dom_document *doc, |
| dom_node *node, bool deep, dom_node **result, |
| dom_node_operation opt); |
| /*----------------------------------------------------------------------*/ |
| /* The constructors and destructors */ |
| /** |
| * Create a Document |
| * |
| * \param doc Pointer to location to receive created document |
| * \param daf The default action fetcher |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * The returned document will already be referenced. |
| */ |
| dom_exception _dom_document_create(dom_events_default_action_fetcher daf, |
| void *daf_ctx, |
| dom_document **doc) |
| { |
| dom_document *d; |
| dom_exception err; |
| /* Create document */ |
| d = malloc(sizeof(dom_document)); |
| if (d == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Initialise the virtual table */ |
| d->base.base.vtable = &document_vtable; |
| d->base.vtable = &document_protect_vtable; |
| /* Initialise base class -- the Document has no parent, so |
| * destruction will be attempted as soon as its reference count |
| * reaches zero. Documents own themselves (this simplifies the |
| * rest of the code, as it doesn't need to special case Documents) |
| */ |
| err = _dom_document_initialise(d, daf, daf_ctx); |
| if (err != DOM_NO_ERR) { |
| /* Clean up document */ |
| free(d); |
| return err; |
| } |
| *doc = d; |
| return DOM_NO_ERR; |
| } |
| /* Initialise the document */ |
| dom_exception _dom_document_initialise(dom_document *doc, |
| dom_events_default_action_fetcher daf, |
| void *daf_ctx) |
| { |
| dom_exception err; |
| dom_string *name; |
| err = dom_string_create((const uint8_t *) "#document", |
| SLEN("#document"), &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| doc->nodelists = NULL; |
| err = _dom_node_initialise(&doc->base, doc, DOM_DOCUMENT_NODE, |
| name, NULL, NULL, NULL); |
| dom_string_unref(name); |
| if (err != DOM_NO_ERR) |
| return err; |
| list_init(&doc->pending_nodes); |
| err = dom_string_create_interned((const uint8_t *) "id", |
| SLEN("id"), &doc->id_name); |
| if (err != DOM_NO_ERR) |
| return err; |
| doc->quirks = DOM_DOCUMENT_QUIRKS_MODE_NONE; |
| err = dom_string_create_interned((const uint8_t *) "class", |
| SLEN("class"), &doc->class_string); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(doc->id_name); |
| return err; |
| } |
| /* Intern the empty string. The use of a space in the constant |
| * is to prevent the compiler warning about an empty string. |
| */ |
| err = dom_string_create_interned((const uint8_t *) " ", 0, |
| &doc->_memo_empty); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(doc->id_name); |
| dom_string_unref(doc->class_string); |
| return err; |
| } |
| err = dom_string_create_interned((const uint8_t *) "DOMNodeInserted", |
| SLEN("DOMNodeInserted"), |
| &doc->_memo_domnodeinserted); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(doc->_memo_empty); |
| dom_string_unref(doc->id_name); |
| dom_string_unref(doc->class_string); |
| return err; |
| } |
| err = dom_string_create_interned((const uint8_t *) "DOMNodeRemoved", |
| SLEN("DOMNodeRemoved"), |
| &doc->_memo_domnoderemoved); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(doc->_memo_domnodeinserted); |
| dom_string_unref(doc->_memo_empty); |
| dom_string_unref(doc->id_name); |
| dom_string_unref(doc->class_string); |
| return err; |
| } |
| err = dom_string_create_interned((const uint8_t *) "DOMNodeInsertedIntoDocument", |
| SLEN("DOMNodeInsertedIntoDocument"), |
| &doc->_memo_domnodeinsertedintodocument); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(doc->_memo_domnoderemoved); |
| dom_string_unref(doc->_memo_domnodeinserted); |
| dom_string_unref(doc->_memo_empty); |
| dom_string_unref(doc->id_name); |
| dom_string_unref(doc->class_string); |
| return err; |
| } |
| err = dom_string_create_interned((const uint8_t *) "DOMNodeRemovedFromDocument", |
| SLEN("DOMNodeRemovedFromDocument"), |
| &doc->_memo_domnoderemovedfromdocument); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(doc->_memo_domnodeinsertedintodocument); |
| dom_string_unref(doc->_memo_domnoderemoved); |
| dom_string_unref(doc->_memo_domnodeinserted); |
| dom_string_unref(doc->_memo_empty); |
| dom_string_unref(doc->id_name); |
| dom_string_unref(doc->class_string); |
| return err; |
| } |
| err = dom_string_create_interned((const uint8_t *) "DOMAttrModified", |
| SLEN("DOMAttrModified"), |
| &doc->_memo_domattrmodified); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(doc->_memo_domnoderemovedfromdocument); |
| dom_string_unref(doc->_memo_domnodeinsertedintodocument); |
| dom_string_unref(doc->_memo_domnoderemoved); |
| dom_string_unref(doc->_memo_domnodeinserted); |
| dom_string_unref(doc->_memo_empty); |
| dom_string_unref(doc->id_name); |
| dom_string_unref(doc->class_string); |
| return err; |
| } |
| err = dom_string_create_interned((const uint8_t *) "DOMCharacterDataModified", |
| SLEN("DOMCharacterDataModified"), |
| &doc->_memo_domcharacterdatamodified); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(doc->_memo_domattrmodified); |
| dom_string_unref(doc->_memo_domnoderemovedfromdocument); |
| dom_string_unref(doc->_memo_domnodeinsertedintodocument); |
| dom_string_unref(doc->_memo_domnoderemoved); |
| dom_string_unref(doc->_memo_domnodeinserted); |
| dom_string_unref(doc->_memo_empty); |
| dom_string_unref(doc->id_name); |
| dom_string_unref(doc->class_string); |
| return err; |
| } |
| err = dom_string_create_interned((const uint8_t *) "DOMSubtreeModified", |
| SLEN("DOMSubtreeModified"), |
| &doc->_memo_domsubtreemodified); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(doc->_memo_domcharacterdatamodified); |
| dom_string_unref(doc->_memo_domattrmodified); |
| dom_string_unref(doc->_memo_domnoderemovedfromdocument); |
| dom_string_unref(doc->_memo_domnodeinsertedintodocument); |
| dom_string_unref(doc->_memo_domnoderemoved); |
| dom_string_unref(doc->_memo_domnodeinserted); |
| dom_string_unref(doc->_memo_empty); |
| dom_string_unref(doc->id_name); |
| dom_string_unref(doc->class_string); |
| return err; |
| } |
| /* We should not pass a NULL when all things hook up */ |
| return _dom_document_event_internal_initialise(doc, &doc->dei, daf, daf_ctx); |
| } |
| /* Finalise the document */ |
| bool _dom_document_finalise(dom_document *doc) |
| { |
| /* Finalise base class, delete the tree in force */ |
| _dom_node_finalise(&doc->base); |
| /* Now, the first_child and last_child should be null */ |
| doc->base.first_child = NULL; |
| doc->base.last_child = NULL; |
| /* Ensure list of nodes pending deletion is empty. If not, |
| * then we can't yet destroy the document (its destruction will |
| * have to wait until the pending nodes are destroyed) */ |
| if (doc->pending_nodes.next != &doc->pending_nodes) |
| return false; |
| /* Ok, the document tree is empty, as is the list of nodes pending |
| * deletion. Therefore, it is safe to destroy the document. */ |
| /* This is paranoia -- if there are any remaining nodelists, |
| * then the document's reference count will be |
| * non-zero as these data structures reference the document because |
| * they are held by the client. */ |
| doc->nodelists = NULL; |
| if (doc->id_name != NULL) |
| dom_string_unref(doc->id_name); |
| dom_string_unref(doc->class_string); |
| dom_string_unref(doc->_memo_empty); |
| dom_string_unref(doc->_memo_domnodeinserted); |
| dom_string_unref(doc->_memo_domnoderemoved); |
| dom_string_unref(doc->_memo_domnodeinsertedintodocument); |
| dom_string_unref(doc->_memo_domnoderemovedfromdocument); |
| dom_string_unref(doc->_memo_domattrmodified); |
| dom_string_unref(doc->_memo_domcharacterdatamodified); |
| dom_string_unref(doc->_memo_domsubtreemodified); |
| _dom_document_event_internal_finalise(doc, &doc->dei); |
| return true; |
| } |
| /*----------------------------------------------------------------------*/ |
| /* Public virtual functions */ |
| /** |
| * Retrieve the doctype of a document |
| * |
| * \param doc The document to retrieve the doctype from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_get_doctype(dom_document *doc, |
| dom_document_type **result) |
| { |
| dom_node_internal *c; |
| for (c = doc->base.first_child; c != NULL; c = c->next) { |
| if (c->type == DOM_DOCUMENT_TYPE_NODE) |
| break; |
| } |
| if (c != NULL) |
| dom_node_ref(c); |
| *result = (dom_document_type *) c; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the DOM implementation that handles this document |
| * |
| * \param doc The document to retrieve the implementation from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned implementation will have its reference count increased. |
| * It is the responsibility of the caller to unref the implementation once |
| * it has finished with it. |
| */ |
| dom_exception _dom_document_get_implementation(dom_document *doc, |
| dom_implementation **result) |
| { |
| UNUSED(doc); |
| *result = (dom_implementation *) "libdom"; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the document element of a document |
| * |
| * \param doc The document to retrieve the document element from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_get_document_element(dom_document *doc, |
| dom_element **result) |
| { |
| dom_node_internal *root; |
| /* Find the first element node in child list */ |
| for (root = doc->base.first_child; root != NULL; root = root->next) { |
| if (root->type == DOM_ELEMENT_NODE) |
| break; |
| } |
| if (root != NULL) |
| dom_node_ref(root); |
| *result = (dom_element *) root; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Create an element |
| * |
| * \param doc The document owning the element |
| * \param tag_name The name of the element |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::tag_name is invalid. |
| * |
| * ::doc and ::tag_name will have their reference counts increased. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_create_element(dom_document *doc, |
| dom_string *tag_name, dom_element **result) |
| { |
| if (_dom_validate_name(tag_name) == false) |
| return DOM_INVALID_CHARACTER_ERR; |
| return _dom_element_create(doc, tag_name, NULL, NULL, result); |
| } |
| /** |
| * Create a document fragment |
| * |
| * \param doc The document owning the fragment |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_create_document_fragment(dom_document *doc, |
| dom_document_fragment **result) |
| { |
| dom_string *name; |
| dom_exception err; |
| err = dom_string_create((const uint8_t *) "#document-fragment", |
| SLEN("#document-fragment"), &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_document_fragment_create(doc, name, NULL, result); |
| dom_string_unref(name); |
| return err; |
| } |
| /** |
| * Create a text node |
| * |
| * \param doc The document owning the node |
| * \param data The data for the node |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_create_text_node(dom_document *doc, |
| dom_string *data, dom_text **result) |
| { |
| dom_string *name; |
| dom_exception err; |
| err = dom_string_create((const uint8_t *) "#text", |
| SLEN("#text"), &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_text_create(doc, name, data, result); |
| dom_string_unref(name); |
| return err; |
| } |
| /** |
| * Create a comment node |
| * |
| * \param doc The document owning the node |
| * \param data The data for the node |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_create_comment(dom_document *doc, |
| dom_string *data, dom_comment **result) |
| { |
| dom_string *name; |
| dom_exception err; |
| err = dom_string_create((const uint8_t *) "#comment", SLEN("#comment"), |
| &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_comment_create(doc, name, data, result); |
| dom_string_unref(name); |
| return err; |
| } |
| /** |
| * Create a CDATA section |
| * |
| * \param doc The document owning the section |
| * \param data The data for the section contents |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_SUPPORTED_ERR if this is an HTML document. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_create_cdata_section(dom_document *doc, |
| dom_string *data, dom_cdata_section **result) |
| { |
| dom_string *name; |
| dom_exception err; |
| err = dom_string_create((const uint8_t *) "#cdata-section", |
| SLEN("#cdata-section"), &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_cdata_section_create(doc, name, data, result); |
| dom_string_unref(name); |
| return err; |
| } |
| /** |
| * Create a processing instruction |
| * |
| * \param doc The document owning the instruction |
| * \param target The instruction target |
| * \param data The data for the node |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::target is invalid, |
| * DOM_NOT_SUPPORTED_ERR if this is an HTML document. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_create_processing_instruction( |
| dom_document *doc, dom_string *target, |
| dom_string *data, |
| dom_processing_instruction **result) |
| { |
| if (_dom_validate_name(target) == false) |
| return DOM_INVALID_CHARACTER_ERR; |
| return _dom_processing_instruction_create(doc, target, data, result); |
| } |
| /** |
| * Create an attribute |
| * |
| * \param doc The document owning the attribute |
| * \param name The name of the attribute |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::name is invalid. |
| * |
| * The constructed attribute will always be classified as 'specified'. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_create_attribute(dom_document *doc, |
| dom_string *name, dom_attr **result) |
| { |
| if (_dom_validate_name(name) == false) |
| return DOM_INVALID_CHARACTER_ERR; |
| return _dom_attr_create(doc, name, NULL, NULL, true, result); |
| } |
| /** |
| * Create an entity reference |
| * |
| * \param doc The document owning the reference |
| * \param name The name of the entity to reference |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::name is invalid, |
| * DOM_NOT_SUPPORTED_ERR if this is an HTML document. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_create_entity_reference(dom_document *doc, |
| dom_string *name, |
| dom_entity_reference **result) |
| { |
| if (_dom_validate_name(name) == false) |
| return DOM_INVALID_CHARACTER_ERR; |
| return _dom_entity_reference_create(doc, name, NULL, result); |
| } |
| /** |
| * Retrieve a list of all elements with a given tag name |
| * |
| * \param doc The document to search in |
| * \param tagname The tag name to search for ("*" for all) |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned list will have its reference count increased. It is |
| * the responsibility of the caller to unref the list once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_get_elements_by_tag_name(dom_document *doc, |
| dom_string *tagname, dom_nodelist **result) |
| { |
| return _dom_document_get_nodelist(doc, DOM_NODELIST_BY_NAME, |
| (dom_node_internal *) doc, tagname, NULL, NULL, |
| result); |
| } |
| /** |
| * Import a node from another document into this one |
| * |
| * \param doc The document to import into |
| * \param node The node to import |
| * \param deep Whether to copy the node's subtree |
| * \param result Pointer to location to receive imported node in this document. |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if any of the names are invalid, |
| * DOM_NOT_SUPPORTED_ERR if the type of ::node is unsupported |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_import_node(dom_document *doc, |
| dom_node *node, bool deep, dom_node **result) |
| { |
| /* TODO: The DOM_INVALID_CHARACTER_ERR exception */ |
| return dom_document_dup_node(doc, node, deep, result, |
| DOM_NODE_IMPORTED); |
| } |
| /** |
| * Create an element from the qualified name and namespace URI |
| * |
| * \param doc The document owning the element |
| * \param namespace The namespace URI to use, or NULL for none |
| * \param qname The qualified name of the element |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::qname is invalid, |
| * DOM_NAMESPACE_ERR if ::qname is malformed, or it has a |
| * prefix and ::namespace is NULL, or |
| * ::qname has a prefix "xml" and |
| * ::namespace is not |
| * "http://www.w3.org/XML/1998/namespace", |
| * or ::qname has a prefix "xmlns" and |
| * ::namespace is not |
| * "http://www.w3.org/2000/xmlns", or |
| * ::namespace is |
| * "http://www.w3.org/2000/xmlns" and |
| * ::qname is not (or is not prefixed by) |
| * "xmlns", |
| * DOM_NOT_SUPPORTED_ERR if ::doc does not support the "XML" |
| * feature. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_create_element_ns(dom_document *doc, |
| dom_string *namespace, dom_string *qname, |
| dom_element **result) |
| { |
| dom_string *prefix, *localname; |
| dom_exception err; |
| if (_dom_validate_name(qname) == false) |
| return DOM_INVALID_CHARACTER_ERR; |
| /* Validate qname */ |
| err = _dom_namespace_validate_qname(qname, namespace); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Divide QName into prefix/localname pair */ |
| err = _dom_namespace_split_qname(qname, &prefix, &localname); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Attempt to create element */ |
| err = _dom_element_create(doc, localname, namespace, prefix, result); |
| /* Tidy up */ |
| if (localname != NULL) { |
| dom_string_unref(localname); |
| } |
| if (prefix != NULL) { |
| dom_string_unref(prefix); |
| } |
| return err; |
| } |
| /** |
| * Create an attribute from the qualified name and namespace URI |
| * |
| * \param doc The document owning the attribute |
| * \param namespace The namespace URI to use |
| * \param qname The qualified name of the attribute |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::qname is invalid, |
| * DOM_NAMESPACE_ERR if ::qname is malformed, or it has a |
| * prefix and ::namespace is NULL, or |
| * ::qname has a prefix "xml" and |
| * ::namespace is not |
| * "http://www.w3.org/XML/1998/namespace", |
| * or ::qname has a prefix "xmlns" and |
| * ::namespace is not |
| * "http://www.w3.org/2000/xmlns", or |
| * ::namespace is |
| * "http://www.w3.org/2000/xmlns" and |
| * ::qname is not (or is not prefixed by) |
| * "xmlns", |
| * DOM_NOT_SUPPORTED_ERR if ::doc does not support the "XML" |
| * feature. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_create_attribute_ns(dom_document *doc, |
| dom_string *namespace, dom_string *qname, |
| dom_attr **result) |
| { |
| dom_string *prefix, *localname; |
| dom_exception err; |
| if (_dom_validate_name(qname) == false) |
| return DOM_INVALID_CHARACTER_ERR; |
| /* Validate qname */ |
| err = _dom_namespace_validate_qname(qname, namespace); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Divide QName into prefix/localname pair */ |
| err = _dom_namespace_split_qname(qname, &prefix, &localname); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Attempt to create attribute */ |
| err = _dom_attr_create(doc, localname, namespace, prefix, true, result); |
| /* Tidy up */ |
| if (localname != NULL) { |
| dom_string_unref(localname); |
| } |
| if (prefix != NULL) { |
| dom_string_unref(prefix); |
| } |
| return err; |
| } |
| /** |
| * Retrieve a list of all elements with a given local name and namespace URI |
| * |
| * \param doc The document to search in |
| * \param namespace The namespace URI |
| * \param localname The local name |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * The returned list will have its reference count increased. It is |
| * the responsibility of the caller to unref the list once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_get_elements_by_tag_name_ns( |
| dom_document *doc, dom_string *namespace, |
| dom_string *localname, dom_nodelist **result) |
| { |
| return _dom_document_get_nodelist(doc, DOM_NODELIST_BY_NAMESPACE, |
| (dom_node_internal *) doc, NULL, namespace, localname, |
| result); |
| } |
| /** |
| * Retrieve the element that matches the specified ID |
| * |
| * \param doc The document to search in |
| * \param id The ID to search for |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_get_element_by_id(dom_document *doc, |
| dom_string *id, dom_element **result) |
| { |
| dom_node_internal *root; |
| dom_exception err; |
| *result = NULL; |
| err = dom_document_get_document_element(doc, (void *) &root); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_find_element_by_id(root, id, result); |
| dom_node_unref(root); |
| return err; |
| } |
| /** |
| * Retrieve the input encoding of the document |
| * |
| * \param doc The document to query |
| * \param result Pointer to location to receive result |
| * \return DOM_NOT_SUPPORTED_ERR, we don't support this API now. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_get_input_encoding(dom_document *doc, |
| dom_string **result) |
| { |
| UNUSED(doc); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Retrieve the XML encoding of the document |
| * |
| * \param doc The document to query |
| * \param result Pointer to location to receive result |
| * \return DOM_NOT_SUPPORTED_ERR, we don't support this API now. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_get_xml_encoding(dom_document *doc, |
| dom_string **result) |
| { |
| UNUSED(doc); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Retrieve the standalone status of the document |
| * |
| * \param doc The document to query |
| * \param result Pointer to location to receive result |
| * \return DOM_NOT_SUPPORTED_ERR, we don't support this API now. |
| */ |
| dom_exception _dom_document_get_xml_standalone(dom_document *doc, |
| bool *result) |
| { |
| UNUSED(doc); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Set the standalone status of the document |
| * |
| * \param doc The document to query |
| * \param standalone Standalone status to use |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_SUPPORTED_ERR if the document does not support the "XML" |
| * feature. |
| * |
| * We don't support this API now, so the return value is always |
| * DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_document_set_xml_standalone(dom_document *doc, |
| bool standalone) |
| { |
| UNUSED(doc); |
| UNUSED(standalone); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Retrieve the XML version of the document |
| * |
| * \param doc The document to query |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| * |
| * We don't support this API now, so the return value is always |
| * DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_document_get_xml_version(dom_document *doc, |
| dom_string **result) |
| { |
| UNUSED(doc); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Set the XML version of the document |
| * |
| * \param doc The document to query |
| * \param version XML version to use |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_SUPPORTED_ERR if the document does not support the "XML" |
| * feature. |
| * |
| * We don't support this API now, so the return value is always |
| * DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_document_set_xml_version(dom_document *doc, |
| dom_string *version) |
| { |
| UNUSED(doc); |
| UNUSED(version); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Retrieve the error checking mode of the document |
| * |
| * \param doc The document to query |
| * \param result Pointer to location to receive result |
| * \return DOM_NOT_SUPPORTED_ERR, we don't support this API now. |
| */ |
| dom_exception _dom_document_get_strict_error_checking( |
| dom_document *doc, bool *result) |
| { |
| UNUSED(doc); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Set the error checking mode of the document |
| * |
| * \param doc The document to query |
| * \param strict Whether to use strict error checking |
| * \return DOM_NOT_SUPPORTED_ERR, we don't support this API now. |
| */ |
| dom_exception _dom_document_set_strict_error_checking( |
| dom_document *doc, bool strict) |
| { |
| UNUSED(doc); |
| UNUSED(strict); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Retrieve the URI of the document |
| * |
| * \param doc The document to query |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_get_uri(dom_document *doc, |
| dom_string **result) |
| { |
| *result = dom_string_ref(doc->uri); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the URI of the document |
| * |
| * \param doc The document to query |
| * \param uri The URI to use |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_set_uri(dom_document *doc, |
| dom_string *uri) |
| { |
| dom_string_unref(doc->uri); |
| doc->uri = dom_string_ref(uri); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Attempt to adopt a node from another document into this document |
| * |
| * \param doc The document to adopt into |
| * \param node The node to adopt |
| * \param result Pointer to location to receive adopted node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::node is readonly, |
| * DOM_NOT_SUPPORTED_ERR if ::node is of type Document or |
| * DocumentType |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| * |
| * @note: The spec said adoptNode may be light weight than the importNode |
| * because the former need no Node creation. But in our implementation |
| * this can't be ensured. Both adoptNode and importNode create new |
| * nodes using the importing/adopting document's resource manager. So, |
| * generally, the adoptNode and importNode call the same function |
| * dom_document_dup_node. |
| */ |
| dom_exception _dom_document_adopt_node(dom_document *doc, |
| dom_node *node, dom_node **result) |
| { |
| dom_node_internal *n = (dom_node_internal *) node; |
| dom_exception err; |
| dom_node_internal *parent; |
| dom_node_internal *tmp; |
| *result = NULL; |
| if (n->type == DOM_DOCUMENT_NODE || |
| n->type == DOM_DOCUMENT_TYPE_NODE) { |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| if (n->type == DOM_ENTITY_NODE || |
| n->type == DOM_NOTATION_NODE || |
| n->type == DOM_PROCESSING_INSTRUCTION_NODE || |
| n->type == DOM_TEXT_NODE || |
| n->type == DOM_CDATA_SECTION_NODE || |
| n->type == DOM_COMMENT_NODE) { |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /* Support XML when necessary */ |
| if (n->type == DOM_ENTITY_REFERENCE_NODE) { |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| err = dom_document_dup_node(doc, node, true, result, DOM_NODE_ADOPTED); |
| if (err != DOM_NO_ERR) { |
| *result = NULL; |
| return err; |
| } |
| parent = n->parent; |
| if (parent != NULL) { |
| err = dom_node_remove_child(parent, node, (void *) &tmp); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(*result); |
| *result = NULL; |
| return err; |
| } |
| dom_node_unref(tmp); |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the DOM configuration associated with a document |
| * |
| * \param doc The document to query |
| * \param result Pointer to location to receive result |
| * \return DOM_NOT_SUPPORTED_ERR, we don't support this API now. |
| * |
| * The returned object will have its reference count increased. It is |
| * the responsibility of the caller to unref the object once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_get_dom_config(dom_document *doc, |
| struct dom_configuration **result) |
| { |
| UNUSED(doc); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Normalize a document |
| * |
| * \param doc The document to normalize |
| * \return DOM_NOT_SUPPORTED_ERR, we don't support this API now. |
| */ |
| dom_exception _dom_document_normalize(dom_document *doc) |
| { |
| UNUSED(doc); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Rename a node in a document |
| * |
| * \param doc The document containing the node |
| * \param node The node to rename |
| * \param namespace The new namespace for the node |
| * \param qname The new qualified name for the node |
| * \param result Pointer to location to receive renamed node |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::tag_name is invalid, |
| * DOM_WRONG_DOCUMENT_ERR if ::node was created in a different |
| * document |
| * DOM_NAMESPACE_ERR if ::qname is malformed, or it has a |
| * prefix and ::namespace is NULL, or |
| * ::qname has a prefix "xml" and |
| * ::namespace is not |
| * "http://www.w3.org/XML/1998/namespace", |
| * or ::qname has a prefix "xmlns" and |
| * ::namespace is not |
| * "http://www.w3.org/2000/xmlns", or |
| * ::namespace is |
| * "http://www.w3.org/2000/xmlns" and |
| * ::qname is not (or is not prefixed by) |
| * "xmlns", |
| * DOM_NOT_SUPPORTED_ERR if ::doc does not support the "XML" |
| * feature. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| * |
| * We don't support this API now, so the return value is always |
| * DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_document_rename_node(dom_document *doc, |
| dom_node *node, |
| dom_string *namespace, dom_string *qname, |
| dom_node **result) |
| { |
| UNUSED(doc); |
| UNUSED(node); |
| UNUSED(namespace); |
| UNUSED(qname); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_document_get_text_content(dom_node_internal *node, |
| dom_string **result) |
| { |
| UNUSED(node); |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_document_set_text_content(dom_node_internal *node, |
| dom_string *content) |
| { |
| UNUSED(node); |
| UNUSED(content); |
| return DOM_NO_ERR; |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Overload protected virtual functions */ |
| /* The virtual destroy function of this class */ |
| void _dom_document_destroy(dom_node_internal *node) |
| { |
| dom_document *doc = (dom_document *) node; |
| if (_dom_document_finalise(doc) == true) { |
| free(doc); |
| } |
| } |
| /* The copy constructor function of this class */ |
| dom_exception _dom_document_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| UNUSED(old); |
| UNUSED(copy); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /* ----------------------------------------------------------------------- */ |
| /* Helper functions */ |
| /** |
| * Get a nodelist, creating one if necessary |
| * |
| * \param doc The document to get a nodelist for |
| * \param type The type of the NodeList |
| * \param root Root node of subtree that list applies to |
| * \param tagname Name of nodes in list (or NULL) |
| * \param namespace Namespace part of nodes in list (or NULL) |
| * \param localname Local part of nodes in list (or NULL) |
| * \param list Pointer to location to receive list |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion |
| * |
| * The returned list will have its reference count increased. It is |
| * the responsibility of the caller to unref the list once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_get_nodelist(dom_document *doc, |
| nodelist_type type, dom_node_internal *root, |
| dom_string *tagname, dom_string *namespace, |
| dom_string *localname, dom_nodelist **list) |
| { |
| struct dom_doc_nl *l; |
| dom_exception err; |
| for (l = doc->nodelists; l; l = l->next) { |
| if (_dom_nodelist_match(l->list, type, root, tagname, |
| namespace, localname)) |
| break; |
| } |
| if (l != NULL) { |
| /* Found an existing list, so use it */ |
| dom_nodelist_ref(l->list); |
| } else { |
| /* No existing list */ |
| /* Create active list entry */ |
| l = malloc(sizeof(struct dom_doc_nl)); |
| if (l == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Create nodelist */ |
| err = _dom_nodelist_create(doc, type, root, tagname, namespace, |
| localname, &l->list); |
| if (err != DOM_NO_ERR) { |
| free(l); |
| return err; |
| } |
| /* Add to document's list of active nodelists */ |
| l->prev = NULL; |
| l->next = doc->nodelists; |
| if (doc->nodelists) |
| doc->nodelists->prev = l; |
| doc->nodelists = l; |
| } |
| /* Note: the document does not claim a reference on the nodelist |
| * If it did, the nodelist's reference count would never reach zero, |
| * and the list would remain indefinitely. This is not a problem as |
| * the list notifies the document of its destruction via |
| * _dom_document_remove_nodelist. */ |
| *list = l->list; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Remove a nodelist from a document |
| * |
| * \param doc The document to remove the list from |
| * \param list The list to remove |
| */ |
| void _dom_document_remove_nodelist(dom_document *doc, |
| dom_nodelist *list) |
| { |
| struct dom_doc_nl *l; |
| for (l = doc->nodelists; l; l = l->next) { |
| if (l->list == list) |
| break; |
| } |
| if (l == NULL) { |
| /* This should never happen; we should probably abort here */ |
| return; |
| } |
| /* Remove from list */ |
| if (l->prev != NULL) |
| l->prev->next = l->next; |
| else |
| doc->nodelists = l->next; |
| if (l->next != NULL) |
| l->next->prev = l->prev; |
| /* And free item */ |
| free(l); |
| } |
| /** |
| * Find element with certain ID in the subtree rooted at root |
| * |
| * \param root The root element from where we start |
| * \param id The ID of the target element |
| * \param result The result element |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_find_element_by_id(dom_node_internal *root, |
| dom_string *id, dom_element **result) |
| { |
| dom_node_internal *node = root; |
| *result = NULL; |
| while (node != NULL) { |
| if (node->type == DOM_ELEMENT_NODE) { |
| dom_string *real_id; |
| _dom_element_get_id((dom_element *) node, &real_id); |
| if (real_id != NULL) { |
| if (dom_string_isequal(real_id, id)) { |
| dom_string_unref(real_id); |
| *result = (dom_element *) node; |
| return DOM_NO_ERR; |
| } |
| dom_string_unref(real_id); |
| } |
| } |
| if (node->first_child != NULL) { |
| /* Has children */ |
| node = node->first_child; |
| } else if (node->next != NULL) { |
| /* No children, but has siblings */ |
| node = node->next; |
| } else { |
| /* No children or siblings. |
| * Find first unvisited relation. */ |
| dom_node_internal *parent = node->parent; |
| while (parent != root && |
| node == parent->last_child) { |
| node = parent; |
| parent = parent->parent; |
| } |
| node = node->next; |
| } |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Duplicate a Node |
| * |
| * \param doc The documen |
| * \param node The node to duplicate |
| * \param deep Whether to make a deep copy |
| * \param result The returned node |
| * \param opt Whether this is adopt or import operation |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_document_dup_node(dom_document *doc, dom_node *node, |
| bool deep, dom_node **result, dom_node_operation opt) |
| { |
| dom_node_internal *n = (dom_node_internal *) node; |
| dom_node_internal *ret; |
| dom_exception err; |
| dom_node_internal *child, *r; |
| dom_user_data *ud; |
| if (opt == DOM_NODE_ADOPTED && _dom_node_readonly(n)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| if (n->type == DOM_DOCUMENT_NODE || |
| n->type == DOM_DOCUMENT_TYPE_NODE) |
| return DOM_NOT_SUPPORTED_ERR; |
| err = dom_node_copy(node, &ret); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (n->type == DOM_ATTRIBUTE_NODE) { |
| _dom_attr_set_specified((dom_attr *) node, true); |
| deep = true; |
| } |
| if (n->type == DOM_ENTITY_REFERENCE_NODE) { |
| deep = false; |
| } |
| if (n->type == DOM_ELEMENT_NODE) { |
| /* Specified attributes are copyied but not default attributes, |
| * if the document object hold all the default attributes, we |
| * have nothing to do here */ |
| } |
| if (opt == DOM_NODE_ADOPTED && (n->type == DOM_ENTITY_NODE || |
| n->type == DOM_NOTATION_NODE)) { |
| /* We did not support XML now */ |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| if (deep == true) { |
| child = ((dom_node_internal *) node)->first_child; |
| while (child != NULL) { |
| err = dom_document_import_node(doc, child, deep, |
| (void *) &r); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(ret); |
| return err; |
| } |
| err = dom_node_append_child(ret, r, (void *) &r); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(ret); |
| dom_node_unref(r); |
| return err; |
| } |
| dom_node_unref(r); |
| child = child->next; |
| } |
| } |
| /* Call the dom_user_data_handlers */ |
| ud = n->user_data; |
| while (ud != NULL) { |
| if (ud->handler != NULL) { |
| ud->handler(opt, ud->key, ud->data, node, |
| (dom_node *) ret); |
| } |
| ud = ud->next; |
| } |
| *result = (dom_node *) ret; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Try to destroy the document. |
| * |
| * \param doc The instance of Document |
| * |
| * Delete the document if: |
| * 1. The refcnt reach zero |
| * 2. The pending list is empty |
| * |
| * else, do nothing. |
| */ |
| void _dom_document_try_destroy(dom_document *doc) |
| { |
| if (doc->base.base.refcnt != 0 || doc->base.parent != NULL) |
| return; |
| _dom_document_destroy((dom_node_internal *) doc); |
| } |
| /** |
| * Set the ID attribute name of this document |
| * |
| * \param doc The document object |
| * \param name The ID name of the elements in this document |
| */ |
| void _dom_document_set_id_name(dom_document *doc, dom_string *name) |
| { |
| if (doc->id_name != NULL) |
| dom_string_unref(doc->id_name); |
| doc->id_name = dom_string_ref(name); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Semi-internal API extensions for NetSurf */ |
| dom_exception _dom_document_get_quirks_mode(dom_document *doc, |
| dom_document_quirks_mode *result) |
| { |
| *result = doc->quirks; |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_document_set_quirks_mode(dom_document *doc, |
| dom_document_quirks_mode quirks) |
| { |
| doc->quirks = quirks; |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/core/document.h |
|---|
| 0,0 → 1,302 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_document_h_ |
| #define dom_internal_core_document_h_ |
| #include <inttypes.h> |
| #include <stddef.h> |
| #include <dom/core/node.h> |
| #include <dom/core/attr.h> |
| #include <dom/core/cdatasection.h> |
| #include <dom/core/comment.h> |
| #include <dom/core/document.h> |
| #include <dom/core/document_type.h> |
| #include <dom/core/doc_fragment.h> |
| #include <dom/core/element.h> |
| #include <dom/core/entity_ref.h> |
| #include <dom/core/pi.h> |
| #include <dom/core/text.h> |
| #include <dom/core/implementation.h> |
| #include "core/string.h" |
| #include "core/node.h" |
| #include "core/nodelist.h" |
| #include "utils/hashtable.h" |
| #include "utils/list.h" |
| #include "events/document_event.h" |
| struct dom_doc_nl; |
| /** |
| * DOM document |
| * This should be protected, because later the HTMLDocument will inherit from |
| * this. |
| */ |
| struct dom_document { |
| dom_node_internal base; /**< Base node */ |
| struct dom_doc_nl *nodelists; /**< List of active nodelists */ |
| dom_string *uri; /**< The uri of this document */ |
| struct list_entry pending_nodes; |
| /**< The deletion pending list */ |
| dom_string *id_name; /**< The ID attribute's name */ |
| dom_string *class_string; /**< The string "class". */ |
| dom_document_event_internal dei; |
| /**< The DocumentEvent interface */ |
| dom_document_quirks_mode quirks; |
| /**< Document is in quirks mode */ |
| dom_string *_memo_empty; /**< The string ''. */ |
| /* Memoised event strings */ |
| dom_string *_memo_domnodeinserted; /**< DOMNodeInserted */ |
| dom_string *_memo_domnoderemoved; /**< DOMNodeRemoved */ |
| dom_string *_memo_domnodeinsertedintodocument; /**< DOMNodeInsertedIntoDocument */ |
| dom_string *_memo_domnoderemovedfromdocument; /**< DOMNodeRemovedFromDocument */ |
| dom_string *_memo_domattrmodified; /**< DOMAttrModified */ |
| dom_string *_memo_domcharacterdatamodified; /**< DOMCharacterDataModified */ |
| dom_string *_memo_domsubtreemodified; /**< DOMSubtreeModified */ |
| }; |
| /* Create a DOM document */ |
| dom_exception _dom_document_create(dom_events_default_action_fetcher daf, |
| void *daf_ctx, |
| dom_document **doc); |
| /* Initialise the document */ |
| dom_exception _dom_document_initialise(dom_document *doc, |
| dom_events_default_action_fetcher daf, |
| void *daf_ctx); |
| /* Finalise the document */ |
| bool _dom_document_finalise(dom_document *doc); |
| /* Begin the virtual functions */ |
| dom_exception _dom_document_get_doctype(dom_document *doc, |
| dom_document_type **result); |
| dom_exception _dom_document_get_implementation(dom_document *doc, |
| dom_implementation **result); |
| dom_exception _dom_document_get_document_element(dom_document *doc, |
| dom_element **result); |
| dom_exception _dom_document_create_element(dom_document *doc, |
| dom_string *tag_name, dom_element **result); |
| dom_exception _dom_document_create_document_fragment(dom_document *doc, |
| dom_document_fragment **result); |
| dom_exception _dom_document_create_text_node(dom_document *doc, |
| dom_string *data, dom_text **result); |
| dom_exception _dom_document_create_comment(dom_document *doc, |
| dom_string *data, dom_comment **result); |
| dom_exception _dom_document_create_cdata_section(dom_document *doc, |
| dom_string *data, dom_cdata_section **result); |
| dom_exception _dom_document_create_processing_instruction( |
| dom_document *doc, dom_string *target, |
| dom_string *data, |
| dom_processing_instruction **result); |
| dom_exception _dom_document_create_attribute(dom_document *doc, |
| dom_string *name, dom_attr **result); |
| dom_exception _dom_document_create_entity_reference(dom_document *doc, |
| dom_string *name, |
| dom_entity_reference **result); |
| dom_exception _dom_document_get_elements_by_tag_name(dom_document *doc, |
| dom_string *tagname, dom_nodelist **result); |
| dom_exception _dom_document_import_node(dom_document *doc, |
| dom_node *node, bool deep, dom_node **result); |
| dom_exception _dom_document_create_element_ns(dom_document *doc, |
| dom_string *namespace, dom_string *qname, |
| dom_element **result); |
| dom_exception _dom_document_create_attribute_ns(dom_document *doc, |
| dom_string *namespace, dom_string *qname, |
| dom_attr **result); |
| dom_exception _dom_document_get_elements_by_tag_name_ns( |
| dom_document *doc, dom_string *namespace, |
| dom_string *localname, dom_nodelist **result); |
| dom_exception _dom_document_get_element_by_id(dom_document *doc, |
| dom_string *id, dom_element **result); |
| dom_exception _dom_document_get_input_encoding(dom_document *doc, |
| dom_string **result); |
| dom_exception _dom_document_get_xml_encoding(dom_document *doc, |
| dom_string **result); |
| dom_exception _dom_document_get_xml_standalone(dom_document *doc, |
| bool *result); |
| dom_exception _dom_document_set_xml_standalone(dom_document *doc, |
| bool standalone); |
| dom_exception _dom_document_get_xml_version(dom_document *doc, |
| dom_string **result); |
| dom_exception _dom_document_set_xml_version(dom_document *doc, |
| dom_string *version); |
| dom_exception _dom_document_get_strict_error_checking( |
| dom_document *doc, bool *result); |
| dom_exception _dom_document_set_strict_error_checking( |
| dom_document *doc, bool strict); |
| dom_exception _dom_document_get_uri(dom_document *doc, |
| dom_string **result); |
| dom_exception _dom_document_set_uri(dom_document *doc, |
| dom_string *uri); |
| dom_exception _dom_document_adopt_node(dom_document *doc, |
| dom_node *node, dom_node **result); |
| dom_exception _dom_document_get_dom_config(dom_document *doc, |
| struct dom_configuration **result); |
| dom_exception _dom_document_normalize(dom_document *doc); |
| dom_exception _dom_document_rename_node(dom_document *doc, |
| dom_node *node, |
| dom_string *namespace, dom_string *qname, |
| dom_node **result); |
| dom_exception _dom_document_get_quirks_mode(dom_document *doc, |
| dom_document_quirks_mode *result); |
| dom_exception _dom_document_set_quirks_mode(dom_document *doc, |
| dom_document_quirks_mode result); |
| dom_exception _dom_document_get_text_content(dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_document_set_text_content(dom_node_internal *node, |
| dom_string *content); |
| #define DOM_DOCUMENT_VTABLE \ |
| _dom_document_get_doctype, \ |
| _dom_document_get_implementation, \ |
| _dom_document_get_document_element, \ |
| _dom_document_create_element, \ |
| _dom_document_create_document_fragment, \ |
| _dom_document_create_text_node, \ |
| _dom_document_create_comment, \ |
| _dom_document_create_cdata_section, \ |
| _dom_document_create_processing_instruction, \ |
| _dom_document_create_attribute, \ |
| _dom_document_create_entity_reference, \ |
| _dom_document_get_elements_by_tag_name, \ |
| _dom_document_import_node, \ |
| _dom_document_create_element_ns, \ |
| _dom_document_create_attribute_ns, \ |
| _dom_document_get_elements_by_tag_name_ns, \ |
| _dom_document_get_element_by_id, \ |
| _dom_document_get_input_encoding, \ |
| _dom_document_get_xml_encoding, \ |
| _dom_document_get_xml_standalone, \ |
| _dom_document_set_xml_standalone, \ |
| _dom_document_get_xml_version, \ |
| _dom_document_set_xml_version, \ |
| _dom_document_get_strict_error_checking, \ |
| _dom_document_set_strict_error_checking, \ |
| _dom_document_get_uri, \ |
| _dom_document_set_uri, \ |
| _dom_document_adopt_node, \ |
| _dom_document_get_dom_config, \ |
| _dom_document_normalize, \ |
| _dom_document_rename_node, \ |
| _dom_document_get_quirks_mode, \ |
| _dom_document_set_quirks_mode |
| /* End of vtable */ |
| #define DOM_NODE_VTABLE_DOCUMENT \ |
| _dom_node_try_destroy, \ |
| _dom_node_get_node_name, \ |
| _dom_node_get_node_value, \ |
| _dom_node_set_node_value, \ |
| _dom_node_get_node_type, \ |
| _dom_node_get_parent_node, \ |
| _dom_node_get_child_nodes, \ |
| _dom_node_get_first_child, \ |
| _dom_node_get_last_child, \ |
| _dom_node_get_previous_sibling, \ |
| _dom_node_get_next_sibling, \ |
| _dom_node_get_attributes, \ |
| _dom_node_get_owner_document, \ |
| _dom_node_insert_before, \ |
| _dom_node_replace_child, \ |
| _dom_node_remove_child, \ |
| _dom_node_append_child, \ |
| _dom_node_has_child_nodes, \ |
| _dom_node_clone_node, \ |
| _dom_node_normalize, \ |
| _dom_node_is_supported, \ |
| _dom_node_get_namespace, \ |
| _dom_node_get_prefix, \ |
| _dom_node_set_prefix, \ |
| _dom_node_get_local_name, \ |
| _dom_node_has_attributes, \ |
| _dom_node_get_base, \ |
| _dom_node_compare_document_position, \ |
| _dom_document_get_text_content, \ |
| _dom_document_set_text_content, \ |
| _dom_node_is_same, \ |
| _dom_node_lookup_prefix, \ |
| _dom_node_is_default_namespace, \ |
| _dom_node_lookup_namespace, \ |
| _dom_node_is_equal, \ |
| _dom_node_get_feature, \ |
| _dom_node_set_user_data, \ |
| _dom_node_get_user_data |
| /** \todo Unused! */ |
| /** |
| * The internal used vtable for document |
| */ |
| struct dom_document_protected_vtable { |
| struct dom_node_protect_vtable base; |
| dom_exception (*dom_document_get_base)(dom_document *doc, |
| dom_string **base_uri); |
| /* Get the document's base uri */ |
| }; |
| typedef struct dom_document_protected_vtable dom_document_protected_vtable; |
| /* Get the document's base URI */ |
| static inline dom_exception dom_document_get_base(dom_document *doc, |
| dom_string **base_uri) |
| { |
| dom_node_internal *node = (dom_node_internal *) doc; |
| return ((dom_document_protected_vtable *) node->vtable)-> |
| dom_document_get_base(doc, base_uri); |
| } |
| #define dom_document_get_base(d, b) dom_document_get_base( \ |
| (dom_document *) (d), (dom_string **) (b)) |
| /* Following comes the protected vtable */ |
| void _dom_document_destroy(dom_node_internal *node); |
| dom_exception _dom_document_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_DOCUMENT_PROTECT_VTABLE \ |
| _dom_document_destroy, \ |
| _dom_document_copy |
| /*---------------------------- Helper functions ---------------------------*/ |
| /* Try to destroy the document: |
| * When the refcnt is zero and the pending list is empty, we can destroy this |
| * document. */ |
| void _dom_document_try_destroy(dom_document *doc); |
| /* Get a nodelist, creating one if necessary */ |
| dom_exception _dom_document_get_nodelist(dom_document *doc, |
| nodelist_type type, dom_node_internal *root, |
| dom_string *tagname, dom_string *namespace, |
| dom_string *localname, dom_nodelist **list); |
| /* Remove a nodelist */ |
| void _dom_document_remove_nodelist(dom_document *doc, dom_nodelist *list); |
| /* Find element with certain ID in the subtree rooted at root */ |
| dom_exception _dom_find_element_by_id(dom_node_internal *root, |
| dom_string *id, dom_element **result); |
| /* Set the ID attribute name of this document */ |
| void _dom_document_set_id_name(dom_document *doc, dom_string *name); |
| #define _dom_document_get_id_name(d) (d->id_name) |
| #endif |
| /contrib/network/netsurf/libdom/src/core/document_type.c |
|---|
| 0,0 → 1,343 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2007 James Shaw <jshaw@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include "core/string.h" |
| #include "core/document_type.h" |
| #include "core/namednodemap.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| #include "utils/namespace.h" |
| /** |
| * DOM DocumentType node |
| */ |
| struct dom_document_type { |
| dom_node_internal base; /**< Base node */ |
| dom_string *public_id; /**< Doctype public ID */ |
| dom_string *system_id; /**< Doctype system ID */ |
| }; |
| static struct dom_document_type_vtable document_type_vtable = { |
| { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE |
| }, |
| DOM_NODE_VTABLE_DOCUMENT_TYPE |
| }, |
| DOM_DOCUMENT_TYPE_VTABLE |
| }; |
| static struct dom_node_protect_vtable dt_protect_vtable = { |
| DOM_DT_PROTECT_VTABLE |
| }; |
| /*----------------------------------------------------------------------*/ |
| /* Constructors and destructors */ |
| /** |
| * Create a document type node |
| * |
| * \param qname The qualified name of the document type |
| * \param public_id The external subset public identifier |
| * \param system_id The external subset system identifier |
| * \param alloc Memory (de)allocation function |
| * \param pw Pointer to client-specific private data |
| * \param doctype Pointer to location to receive result |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * The doctype will be referenced, so the client need not do so |
| * explicitly. The client must unref the doctype once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_type_create(dom_string *qname, |
| dom_string *public_id, dom_string *system_id, |
| dom_document_type **doctype) |
| { |
| dom_document_type *result; |
| dom_exception err; |
| /* Create node */ |
| result = malloc(sizeof(dom_document_type)); |
| if (result == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Initialise the vtable */ |
| result->base.base.vtable = &document_type_vtable; |
| result->base.vtable = &dt_protect_vtable; |
| err = _dom_document_type_initialise(result, qname, |
| public_id, system_id); |
| if (err != DOM_NO_ERR) { |
| free(result); |
| return err; |
| } |
| *doctype = result; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Destroy a DocumentType node |
| * |
| * \param doctype The DocumentType node to destroy |
| * |
| * The contents of ::doctype will be destroyed and ::doctype will be freed. |
| */ |
| void _dom_document_type_destroy(dom_node_internal *doctypenode) |
| { |
| dom_document_type *doctype = (dom_document_type *) doctypenode; |
| /* Finalise base class */ |
| _dom_document_type_finalise(doctype); |
| /* Free doctype */ |
| free(doctype); |
| } |
| /* Initialise this document_type */ |
| dom_exception _dom_document_type_initialise(dom_document_type *doctype, |
| dom_string *qname, dom_string *public_id, |
| dom_string *system_id) |
| { |
| dom_string *prefix, *localname; |
| dom_exception err; |
| err = _dom_namespace_split_qname(qname, &prefix, &localname); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* TODO: I should figure out how the namespaceURI can be got */ |
| /* Initialise base node */ |
| err = _dom_node_initialise(&doctype->base, NULL, |
| DOM_DOCUMENT_TYPE_NODE, localname, NULL, NULL, prefix); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(prefix); |
| dom_string_unref(localname); |
| return err; |
| } |
| /* Get public and system IDs */ |
| if (public_id != NULL) |
| dom_string_ref(public_id); |
| doctype->public_id = public_id; |
| if (system_id != NULL) |
| dom_string_ref(system_id); |
| doctype->system_id = system_id; |
| if (prefix != NULL) |
| dom_string_unref(prefix); |
| if (localname != NULL) |
| dom_string_unref(localname); |
| return DOM_NO_ERR; |
| } |
| /* The destructor function of dom_document_type */ |
| void _dom_document_type_finalise(dom_document_type *doctype) |
| { |
| if (doctype->public_id != NULL) |
| dom_string_unref(doctype->public_id); |
| if (doctype->system_id != NULL) |
| dom_string_unref(doctype->system_id); |
| assert(doctype->base.owner != NULL || doctype->base.user_data == NULL); |
| _dom_node_finalise(&doctype->base); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* Virtual functions */ |
| /** |
| * Retrieve a document type's name |
| * |
| * \param doc_type Document type to retrieve name from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| * |
| * We don't support this API now, so this function call should always |
| * return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_document_type_get_name(dom_document_type *doc_type, |
| dom_string **result) |
| { |
| return dom_node_get_node_name(doc_type, result); |
| } |
| /** |
| * Retrieve a document type's entities |
| * |
| * \param doc_type Document type to retrieve entities from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned map will have its reference count increased. It is |
| * the responsibility of the caller to unref the map once it has |
| * finished with it. |
| * |
| * We don't support this API now, so this function call should always |
| * return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_document_type_get_entities( |
| dom_document_type *doc_type, |
| dom_namednodemap **result) |
| { |
| UNUSED(doc_type); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Retrieve a document type's notations |
| * |
| * \param doc_type Document type to retrieve notations from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned map will have its reference count increased. It is |
| * the responsibility of the caller to unref the map once it has |
| * finished with it. |
| * |
| * We don't support this API now, so this function call should always |
| * return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_document_type_get_notations( |
| dom_document_type *doc_type, |
| dom_namednodemap **result) |
| { |
| UNUSED(doc_type); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Retrieve a document type's public id |
| * |
| * \param doc_type Document type to retrieve public id from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_type_get_public_id( |
| dom_document_type *doc_type, |
| dom_string **result) |
| { |
| if (doc_type->public_id != NULL) |
| *result = dom_string_ref(doc_type->public_id); |
| else |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve a document type's system id |
| * |
| * \param doc_type Document type to retrieve system id from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_document_type_get_system_id( |
| dom_document_type *doc_type, |
| dom_string **result) |
| { |
| if (doc_type->system_id != NULL) |
| *result = dom_string_ref(doc_type->system_id); |
| else |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve a document type's internal subset |
| * |
| * \param doc_type Document type to retrieve internal subset from |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| * |
| * We don't support this API now, so this function call should always |
| * return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_document_type_get_internal_subset( |
| dom_document_type *doc_type, |
| dom_string **result) |
| { |
| UNUSED(doc_type); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_document_type_get_text_content(dom_node_internal *node, |
| dom_string **result) |
| { |
| UNUSED(node); |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_document_type_set_text_content(dom_node_internal *node, |
| dom_string *content) |
| { |
| UNUSED(node); |
| UNUSED(content); |
| return DOM_NO_ERR; |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Overload protected virtual functions */ |
| /* The virtual destroy function of this class */ |
| void _dom_dt_destroy(dom_node_internal *node) |
| { |
| _dom_document_type_destroy(node); |
| } |
| /* The copy constructor of this class */ |
| dom_exception _dom_dt_copy(dom_node_internal *old, dom_node_internal **copy) |
| { |
| UNUSED(old); |
| UNUSED(copy); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/core/document_type.h |
|---|
| 0,0 → 1,107 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_document_type_h_ |
| #define dom_internal_core_document_type_h_ |
| #include <dom/core/document_type.h> |
| struct dom_namednodemap; |
| /* Create a DOM document type */ |
| dom_exception _dom_document_type_create(dom_string *qname, |
| dom_string *public_id, |
| dom_string *system_id, |
| dom_document_type **doctype); |
| /* Destroy a document type */ |
| void _dom_document_type_destroy(dom_node_internal *doctypenode); |
| dom_exception _dom_document_type_initialise(dom_document_type *doctype, |
| dom_string *qname, dom_string *public_id, |
| dom_string *system_id); |
| void _dom_document_type_finalise(dom_document_type *doctype); |
| /* The virtual functions of DocumentType */ |
| dom_exception _dom_document_type_get_name(dom_document_type *doc_type, |
| dom_string **result); |
| dom_exception _dom_document_type_get_entities( |
| dom_document_type *doc_type, |
| struct dom_namednodemap **result); |
| dom_exception _dom_document_type_get_notations( |
| dom_document_type *doc_type, |
| struct dom_namednodemap **result); |
| dom_exception _dom_document_type_get_public_id( |
| dom_document_type *doc_type, |
| dom_string **result); |
| dom_exception _dom_document_type_get_system_id( |
| dom_document_type *doc_type, |
| dom_string **result); |
| dom_exception _dom_document_type_get_internal_subset( |
| dom_document_type *doc_type, |
| dom_string **result); |
| dom_exception _dom_document_type_get_text_content(dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_document_type_set_text_content(dom_node_internal *node, |
| dom_string *content); |
| #define DOM_DOCUMENT_TYPE_VTABLE \ |
| _dom_document_type_get_name, \ |
| _dom_document_type_get_entities, \ |
| _dom_document_type_get_notations, \ |
| _dom_document_type_get_public_id, \ |
| _dom_document_type_get_system_id, \ |
| _dom_document_type_get_internal_subset |
| #define DOM_NODE_VTABLE_DOCUMENT_TYPE \ |
| _dom_node_try_destroy, \ |
| _dom_node_get_node_name, \ |
| _dom_node_get_node_value, \ |
| _dom_node_set_node_value, \ |
| _dom_node_get_node_type, \ |
| _dom_node_get_parent_node, \ |
| _dom_node_get_child_nodes, \ |
| _dom_node_get_first_child, \ |
| _dom_node_get_last_child, \ |
| _dom_node_get_previous_sibling, \ |
| _dom_node_get_next_sibling, \ |
| _dom_node_get_attributes, \ |
| _dom_node_get_owner_document, \ |
| _dom_node_insert_before, \ |
| _dom_node_replace_child, \ |
| _dom_node_remove_child, \ |
| _dom_node_append_child, \ |
| _dom_node_has_child_nodes, \ |
| _dom_node_clone_node, \ |
| _dom_node_normalize, \ |
| _dom_node_is_supported, \ |
| _dom_node_get_namespace, \ |
| _dom_node_get_prefix, \ |
| _dom_node_set_prefix, \ |
| _dom_node_get_local_name, \ |
| _dom_node_has_attributes, \ |
| _dom_node_get_base, \ |
| _dom_node_compare_document_position, \ |
| _dom_document_type_get_text_content, \ |
| _dom_document_type_set_text_content, \ |
| _dom_node_is_same, \ |
| _dom_node_lookup_prefix, \ |
| _dom_node_is_default_namespace, \ |
| _dom_node_lookup_namespace, \ |
| _dom_node_is_equal, \ |
| _dom_node_get_feature, \ |
| _dom_node_set_user_data, \ |
| _dom_node_get_user_data |
| /* Following comes the protected vtable */ |
| void _dom_dt_destroy(dom_node_internal *node); |
| dom_exception _dom_dt_copy(dom_node_internal *old, dom_node_internal **copy); |
| #define DOM_DT_PROTECT_VTABLE \ |
| _dom_dt_destroy, \ |
| _dom_dt_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/core/element.c |
|---|
| 0,0 → 1,2379 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <libwapcaplet/libwapcaplet.h> |
| #include <dom/dom.h> |
| #include <dom/core/attr.h> |
| #include <dom/core/element.h> |
| #include <dom/core/node.h> |
| #include <dom/core/string.h> |
| #include <dom/core/document.h> |
| #include <dom/events/events.h> |
| #include "core/attr.h" |
| #include "core/document.h" |
| #include "core/element.h" |
| #include "core/node.h" |
| #include "core/namednodemap.h" |
| #include "utils/validate.h" |
| #include "utils/namespace.h" |
| #include "utils/utils.h" |
| #include "utils/list.h" |
| #include "events/mutation_event.h" |
| struct dom_element_vtable _dom_element_vtable = { |
| { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE |
| }, |
| DOM_NODE_VTABLE_ELEMENT |
| }, |
| DOM_ELEMENT_VTABLE |
| }; |
| static struct dom_element_protected_vtable element_protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_ELEMENT |
| }, |
| DOM_ELEMENT_PROTECT_VTABLE |
| }; |
| typedef struct dom_attr_list { |
| struct list_entry list; /**< Linked list links to prev/next entries */ |
| struct dom_attr *attr; |
| struct dom_string *name; |
| struct dom_string *namespace; |
| } dom_attr_list; |
| /** |
| * Destroy element's class cache |
| * |
| * \param ele The element |
| */ |
| static void _dom_element_destroy_classes(struct dom_element *ele) |
| { |
| /* Destroy the pre-separated class names */ |
| if (ele->classes != NULL) { |
| unsigned int class; |
| for (class = 0; class < ele->n_classes; class++) { |
| lwc_string_unref(ele->classes[class]); |
| } |
| free(ele->classes); |
| } |
| ele->n_classes = 0; |
| ele->classes = NULL; |
| } |
| /** |
| * Create element's class cache from class attribute value |
| * |
| * \param ele The element |
| * \param value The class attribute value |
| * |
| * Destroys any existing cached classes. |
| */ |
| static dom_exception _dom_element_create_classes(struct dom_element *ele, |
| const char *value) |
| { |
| const char *pos; |
| lwc_string **classes = NULL; |
| uint32_t n_classes = 0; |
| /* Any existing cached classes are replaced; destroy them */ |
| _dom_element_destroy_classes(ele); |
| /* Count number of classes */ |
| for (pos = value; *pos != '\0'; ) { |
| if (*pos != ' ') { |
| while (*pos != ' ' && *pos != '\0') |
| pos++; |
| n_classes++; |
| } else { |
| while (*pos == ' ') |
| pos++; |
| } |
| } |
| /* If there are some, unpack them */ |
| if (n_classes > 0) { |
| classes = malloc(n_classes * sizeof(lwc_string *)); |
| if (classes == NULL) |
| return DOM_NO_MEM_ERR; |
| for (pos = value, n_classes = 0; |
| *pos != '\0'; ) { |
| if (*pos != ' ') { |
| const char *s = pos; |
| while (*pos != ' ' && *pos != '\0') |
| pos++; |
| if (lwc_intern_string(s, pos - s, |
| &classes[n_classes++]) != |
| lwc_error_ok) |
| goto error; |
| } else { |
| while (*pos == ' ') |
| pos++; |
| } |
| } |
| } |
| ele->n_classes = n_classes; |
| ele->classes = classes; |
| return DOM_NO_ERR; |
| error: |
| while (n_classes > 0) |
| lwc_string_unref(classes[--n_classes]); |
| free(classes); |
| return DOM_NO_MEM_ERR; |
| } |
| /* Attribute linked list releated functions */ |
| /** |
| * Get the next attribute in the list |
| * |
| * \param n The attribute list node |
| * \return The next attribute node |
| */ |
| static dom_attr_list * _dom_element_attr_list_next(const dom_attr_list *n) |
| { |
| return (dom_attr_list *)(n->list.next); |
| } |
| /** |
| * Unlink an attribute list node from its linked list |
| * |
| * \param n The attribute list node |
| */ |
| static void _dom_element_attr_list_node_unlink(dom_attr_list *n) |
| { |
| if (n == NULL) |
| return; |
| list_del(&n->list); |
| } |
| /** |
| * Insert attribute list node into attribute list |
| * |
| * \param list The list header |
| * \param new_attr The attribute node to insert |
| */ |
| static void _dom_element_attr_list_insert(dom_attr_list *list, |
| dom_attr_list *new_attr) |
| { |
| assert(list != NULL); |
| assert(new_attr != NULL); |
| list_append(&list->list, &new_attr->list); |
| } |
| /** |
| * Get attribute from attribute list, which matches given name |
| * |
| * \param list The attribute list to search |
| * \param name The name of the attribute to search for |
| * \param name The namespace of the attribute to search for (may be NULL) |
| * \return the matching attribute, or NULL if none found |
| */ |
| static dom_attr_list * _dom_element_attr_list_find_by_name( |
| dom_attr_list *list, dom_string *name, dom_string *namespace) |
| { |
| dom_attr_list *attr = list; |
| if (list == NULL || name == NULL) |
| return NULL; |
| do { |
| if (((namespace == NULL && attr->namespace == NULL) || |
| (namespace != NULL && attr->namespace != NULL && |
| dom_string_isequal(namespace, |
| attr->namespace))) && |
| dom_string_isequal(name, attr->name)) { |
| /* Both have NULL namespace or matching namespace, |
| * and both have same name */ |
| return attr; |
| } |
| attr = _dom_element_attr_list_next(attr); |
| assert(attr != NULL); |
| } while (attr != list); |
| return NULL; |
| } |
| /** |
| * Get the number of elements in this attribute list |
| * |
| * \param list The attribute list |
| * \return the number attribute list node elements |
| */ |
| static unsigned int _dom_element_attr_list_length(dom_attr_list *list) |
| { |
| dom_attr_list *attr = list; |
| unsigned int count = 0; |
| if (list == NULL) |
| return count; |
| do { |
| count++; |
| attr = _dom_element_attr_list_next(attr); |
| } while (attr != list); |
| return count; |
| } |
| /** |
| * Get the attribute list node at the given index |
| * |
| * \param list The attribute list |
| * \param index The index number |
| * \return the attribute list node at given index |
| */ |
| static dom_attr_list * _dom_element_attr_list_get_by_index(dom_attr_list *list, |
| unsigned int index) |
| { |
| dom_attr_list *attr = list; |
| if (list == NULL) |
| return NULL; |
| do { |
| if (--index == 0) |
| return attr; |
| attr = _dom_element_attr_list_next(attr); |
| } while (attr != list); |
| return NULL; |
| } |
| /** |
| * Destroy an attribute list node, and its attribute |
| * |
| * \param n The attribute list node to destroy |
| */ |
| static void _dom_element_attr_list_node_destroy(dom_attr_list *n) |
| { |
| dom_node_internal *a; |
| dom_document *doc; |
| assert(n != NULL); |
| assert(n->attr != NULL); |
| assert(n->name != NULL); |
| a = (dom_node_internal *) n->attr; |
| /* Need to destroy classes cache, when removing class attribute */ |
| doc = a->owner; |
| if (n->namespace == NULL && |
| dom_string_isequal(n->name, doc->class_string)) { |
| _dom_element_destroy_classes((dom_element *)(a->parent)); |
| } |
| /* Destroy rest of list node */ |
| dom_string_unref(n->name); |
| if (n->namespace != NULL) |
| dom_string_unref(n->namespace); |
| a->parent = NULL; |
| dom_node_try_destroy(a); |
| free(n); |
| } |
| /** |
| * Create an attribute list node |
| * |
| * \param attr The attribute to create a list node for |
| * \param name The attribute name |
| * \param namespace The attribute namespace (may be NULL) |
| * \return the new attribute list node, or NULL on failure |
| */ |
| static dom_attr_list * _dom_element_attr_list_node_create(dom_attr *attr, |
| dom_element *ele, dom_string *name, dom_string *namespace) |
| { |
| dom_attr_list *new_list_node; |
| dom_node_internal *a; |
| dom_document *doc; |
| if (attr == NULL || name == NULL) |
| return NULL; |
| new_list_node = malloc(sizeof(*new_list_node)); |
| if (new_list_node == NULL) |
| return NULL; |
| list_init(&new_list_node->list); |
| new_list_node->attr = attr; |
| new_list_node->name = name; |
| new_list_node->namespace = namespace; |
| a = (dom_node_internal *) attr; |
| doc = a->owner; |
| if (namespace == NULL && |
| dom_string_isequal(name, doc->class_string)) { |
| dom_string *value; |
| if (DOM_NO_ERR != _dom_attr_get_value(attr, &value)) { |
| _dom_element_attr_list_node_destroy(new_list_node); |
| return NULL; |
| } |
| if (DOM_NO_ERR != _dom_element_create_classes(ele, |
| dom_string_data(value))) { |
| _dom_element_attr_list_node_destroy(new_list_node); |
| dom_string_unref(value); |
| return NULL; |
| } |
| dom_string_unref(value); |
| } |
| return new_list_node; |
| } |
| /** |
| * Destroy an entire attribute list, and its attributes |
| * |
| * \param list The attribute list to destroy |
| */ |
| static void _dom_element_attr_list_destroy(dom_attr_list *list) |
| { |
| dom_attr_list *attr = list; |
| dom_attr_list *next = list; |
| if (list == NULL) |
| return; |
| do { |
| attr = next; |
| next = _dom_element_attr_list_next(attr); |
| _dom_element_attr_list_node_unlink(attr); |
| _dom_element_attr_list_node_destroy(attr); |
| } while (next != attr); |
| return; |
| } |
| /** |
| * Clone an attribute list node, and its attribute |
| * |
| * \param n The attribute list node to clone |
| * \param newe Element to clone attribute for |
| * \return the new attribute list node, or NULL on failure |
| */ |
| static dom_attr_list *_dom_element_attr_list_node_clone(dom_attr_list *n, |
| dom_element *newe) |
| { |
| dom_attr *clone = NULL; |
| dom_attr_list *new_list_node; |
| dom_exception err; |
| assert(n != NULL); |
| assert(n->attr != NULL); |
| assert(n->name != NULL); |
| new_list_node = malloc(sizeof(*new_list_node)); |
| if (new_list_node == NULL) |
| return NULL; |
| list_init(&new_list_node->list); |
| new_list_node->name = NULL; |
| new_list_node->namespace = NULL; |
| err = dom_node_clone_node(n->attr, true, (void *) &clone); |
| if (err != DOM_NO_ERR) { |
| free(new_list_node); |
| return NULL; |
| } |
| dom_node_set_parent(clone, newe); |
| dom_node_remove_pending(clone); |
| dom_node_unref(clone); |
| new_list_node->attr = clone; |
| if (n->name != NULL) |
| new_list_node->name = dom_string_ref(n->name); |
| if (n->namespace != NULL) |
| new_list_node->namespace = dom_string_ref(n->namespace); |
| return new_list_node; |
| } |
| /** |
| * Clone an entire attribute list, and its attributes |
| * |
| * \param list The attribute list to clone |
| * \param newe Element to clone list for |
| * \return the new attribute list, or NULL on failure |
| */ |
| static dom_attr_list *_dom_element_attr_list_clone(dom_attr_list *list, |
| dom_element *newe) |
| { |
| dom_attr_list *attr = list; |
| dom_attr_list *new_list = NULL; |
| dom_attr_list *new_list_node = NULL; |
| if (list == NULL) |
| return NULL; |
| do { |
| new_list_node = _dom_element_attr_list_node_clone(attr, newe); |
| if (new_list_node == NULL) { |
| if (new_list != NULL) |
| _dom_element_attr_list_destroy(new_list); |
| return NULL; |
| } |
| if (new_list == NULL) { |
| new_list = new_list_node; |
| } else { |
| _dom_element_attr_list_insert(new_list, new_list_node); |
| } |
| attr = _dom_element_attr_list_next(attr); |
| } while (attr != list); |
| return new_list; |
| } |
| static dom_exception _dom_element_get_attr(struct dom_element *element, |
| dom_string *namespace, dom_string *name, dom_string **value); |
| static dom_exception _dom_element_set_attr(struct dom_element *element, |
| dom_string *namespace, dom_string *name, dom_string *value); |
| static dom_exception _dom_element_remove_attr(struct dom_element *element, |
| dom_string *namespace, dom_string *name); |
| static dom_exception _dom_element_get_attr_node(struct dom_element *element, |
| dom_string *namespace, dom_string *name, |
| struct dom_attr **result); |
| static dom_exception _dom_element_set_attr_node(struct dom_element *element, |
| dom_string *namespace, struct dom_attr *attr, |
| struct dom_attr **result); |
| static dom_exception _dom_element_remove_attr_node(struct dom_element *element, |
| dom_string *namespace, struct dom_attr *attr, |
| struct dom_attr **result); |
| static dom_exception _dom_element_has_attr(struct dom_element *element, |
| dom_string *namespace, dom_string *name, bool *result); |
| static dom_exception _dom_element_set_id_attr(struct dom_element *element, |
| dom_string *namespace, dom_string *name, bool is_id); |
| /* The operation set for namednodemap */ |
| static dom_exception attributes_get_length(void *priv, |
| uint32_t *length); |
| static dom_exception attributes_get_named_item(void *priv, |
| dom_string *name, struct dom_node **node); |
| static dom_exception attributes_set_named_item(void *priv, |
| struct dom_node *arg, struct dom_node **node); |
| static dom_exception attributes_remove_named_item( |
| void *priv, dom_string *name, |
| struct dom_node **node); |
| static dom_exception attributes_item(void *priv, |
| uint32_t index, struct dom_node **node); |
| static dom_exception attributes_get_named_item_ns( |
| void *priv, dom_string *namespace, |
| dom_string *localname, struct dom_node **node); |
| static dom_exception attributes_set_named_item_ns( |
| void *priv, struct dom_node *arg, |
| struct dom_node **node); |
| static dom_exception attributes_remove_named_item_ns( |
| void *priv, dom_string *namespace, |
| dom_string *localname, struct dom_node **node); |
| static void attributes_destroy(void *priv); |
| static bool attributes_equal(void *p1, void *p2); |
| static struct nnm_operation attributes_opt = { |
| attributes_get_length, |
| attributes_get_named_item, |
| attributes_set_named_item, |
| attributes_remove_named_item, |
| attributes_item, |
| attributes_get_named_item_ns, |
| attributes_set_named_item_ns, |
| attributes_remove_named_item_ns, |
| attributes_destroy, |
| attributes_equal |
| }; |
| /*----------------------------------------------------------------------*/ |
| /* Constructors and Destructors */ |
| /** |
| * Create an element node |
| * |
| * \param doc The owning document |
| * \param name The (local) name of the node to create |
| * \param namespace The namespace URI of the element, or NULL |
| * \param prefix The namespace prefix of the element, or NULL |
| * \param result Pointer to location to receive created element |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::name is invalid, |
| * DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * ::doc, ::name, ::namespace and ::prefix will have their |
| * reference counts increased. |
| * |
| * The returned element will already be referenced. |
| */ |
| dom_exception _dom_element_create(struct dom_document *doc, |
| dom_string *name, dom_string *namespace, |
| dom_string *prefix, struct dom_element **result) |
| { |
| /* Allocate the element */ |
| *result = malloc(sizeof(struct dom_element)); |
| if (*result == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Initialise the vtables */ |
| (*result)->base.base.vtable = &_dom_element_vtable; |
| (*result)->base.vtable = &element_protect_vtable; |
| return _dom_element_initialise(doc, *result, name, namespace, prefix); |
| } |
| /** |
| * Initialise an element node |
| * |
| * \param doc The owning document |
| * \param el The element |
| * \param name The (local) name of the node to create |
| * \param namespace The namespace URI of the element, or NULL |
| * \param prefix The namespace prefix of the element, or NULL |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::name is invalid, |
| * DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * The caller should make sure that ::name is a valid NCName. |
| * |
| * ::doc, ::name, ::namespace and ::prefix will have their |
| * reference counts increased. |
| * |
| * The returned element will already be referenced. |
| */ |
| dom_exception _dom_element_initialise(struct dom_document *doc, |
| struct dom_element *el, dom_string *name, |
| dom_string *namespace, dom_string *prefix) |
| { |
| dom_exception err; |
| assert(doc != NULL); |
| el->attributes = NULL; |
| /* Initialise the base class */ |
| err = _dom_node_initialise(&el->base, doc, DOM_ELEMENT_NODE, |
| name, NULL, namespace, prefix); |
| if (err != DOM_NO_ERR) { |
| free(el); |
| return err; |
| } |
| /* Perform our type-specific initialisation */ |
| el->id_ns = NULL; |
| el->id_name = NULL; |
| el->schema_type_info = NULL; |
| el->n_classes = 0; |
| el->classes = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Finalise a dom_element |
| * |
| * \param ele The element |
| */ |
| void _dom_element_finalise(struct dom_element *ele) |
| { |
| /* Destroy attributes attached to this node */ |
| if (ele->attributes != NULL) { |
| _dom_element_attr_list_destroy(ele->attributes); |
| ele->attributes = NULL; |
| } |
| if (ele->schema_type_info != NULL) { |
| /** \todo destroy schema type info */ |
| } |
| /* Destroy the pre-separated class names */ |
| _dom_element_destroy_classes(ele); |
| /* Finalise base class */ |
| _dom_node_finalise(&ele->base); |
| } |
| /** |
| * Destroy an element |
| * |
| * \param element The element to destroy |
| * |
| * The contents of ::element will be destroyed and ::element will be freed. |
| */ |
| void _dom_element_destroy(struct dom_element *element) |
| { |
| _dom_element_finalise(element); |
| /* Free the element */ |
| free(element); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public virtual functions */ |
| /** |
| * Retrieve an element's tag name |
| * |
| * \param element The element to retrieve the name from |
| * \param name Pointer to location to receive name |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_get_tag_name(struct dom_element *element, |
| dom_string **name) |
| { |
| /* This is the same as nodeName */ |
| return dom_node_get_node_name((struct dom_node *) element, name); |
| } |
| /** |
| * Retrieve an attribute from an element by name |
| * |
| * \param element The element to retrieve attribute from |
| * \param name The attribute's name |
| * \param value Pointer to location to receive attribute's value |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_get_attribute(struct dom_element *element, |
| dom_string *name, dom_string **value) |
| { |
| return _dom_element_get_attr(element, NULL, name, value); |
| } |
| /** |
| * Set an attribute on an element by name |
| * |
| * \param element The element to set attribute on |
| * \param name The attribute's name |
| * \param value The attribute's value |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::name is invalid, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly. |
| */ |
| dom_exception _dom_element_set_attribute(struct dom_element *element, |
| dom_string *name, dom_string *value) |
| { |
| return _dom_element_set_attr(element, NULL, name, value); |
| } |
| /** |
| * Remove an attribute from an element by name |
| * |
| * \param element The element to remove attribute from |
| * \param name The name of the attribute to remove |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly. |
| */ |
| dom_exception _dom_element_remove_attribute(struct dom_element *element, |
| dom_string *name) |
| { |
| return _dom_element_remove_attr(element, NULL, name); |
| } |
| /** |
| * Retrieve an attribute node from an element by name |
| * |
| * \param element The element to retrieve attribute node from |
| * \param name The attribute's name |
| * \param result Pointer to location to receive attribute node |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_get_attribute_node(struct dom_element *element, |
| dom_string *name, struct dom_attr **result) |
| { |
| return _dom_element_get_attr_node(element, NULL, name, result); |
| } |
| /** |
| * Set an attribute node on an element, replacing existing node, if present |
| * |
| * \param element The element to add a node to |
| * \param attr The attribute node to add |
| * \param result Pointer to location to receive previous node |
| * \return DOM_NO_ERR on success, |
| * DOM_WRONG_DOCUMENT_ERR if ::attr does not belong to the |
| * same document as ::element, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly, |
| * DOM_INUSE_ATTRIBUTE_ERR if ::attr is already an attribute |
| * of another Element node. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_set_attribute_node(struct dom_element *element, |
| struct dom_attr *attr, struct dom_attr **result) |
| { |
| return _dom_element_set_attr_node(element, NULL, attr, result); |
| } |
| /** |
| * Remove an attribute node from an element |
| * |
| * \param element The element to remove attribute node from |
| * \param attr The attribute node to remove |
| * \param result Pointer to location to receive attribute node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly, |
| * DOM_NOT_FOUND_ERR if ::attr is not an attribute of |
| * ::element. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_remove_attribute_node(struct dom_element *element, |
| struct dom_attr *attr, struct dom_attr **result) |
| { |
| return _dom_element_remove_attr_node(element, NULL, attr, result); |
| } |
| /** |
| * Retrieve a list of descendant elements of an element which match a given |
| * tag name |
| * |
| * \param element The root of the subtree to search |
| * \param name The tag name to match (or "*" for all tags) |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned nodelist will have its reference count increased. It is |
| * the responsibility of the caller to unref the nodelist once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_get_elements_by_tag_name( |
| struct dom_element *element, dom_string *name, |
| struct dom_nodelist **result) |
| { |
| dom_exception err; |
| dom_node_internal *base = (dom_node_internal *) element; |
| assert(base->owner != NULL); |
| err = _dom_document_get_nodelist(base->owner, DOM_NODELIST_BY_NAME, |
| (struct dom_node_internal *) element, name, NULL, |
| NULL, result); |
| return err; |
| } |
| /** |
| * Retrieve an attribute from an element by namespace/localname |
| * |
| * \param element The element to retrieve attribute from |
| * \param namespace The attribute's namespace URI, or NULL |
| * \param localname The attribute's local name |
| * \param value Pointer to location to receive attribute's value |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not support |
| * the feature "XML" and the language exposed |
| * through the Document does not support |
| * Namespaces. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_get_attribute_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *localname, |
| dom_string **value) |
| { |
| return _dom_element_get_attr(element, namespace, localname, value); |
| } |
| /** |
| * Set an attribute on an element by namespace/qualified name |
| * |
| * \param element The element to set attribute on |
| * \param namespace The attribute's namespace URI |
| * \param qname The attribute's qualified name |
| * \param value The attribute's value |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::qname is invalid, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly, |
| * DOM_NAMESPACE_ERR if ::qname is malformed, or |
| * ::qname has a prefix and |
| * ::namespace is null, or ::qname |
| * has a prefix "xml" and |
| * ::namespace is not |
| * "http://www.w3.org/XML/1998/namespace", |
| * or ::qname has a prefix "xmlns" |
| * and ::namespace is not |
| * "http://www.w3.org/2000/xmlns", |
| * or ::namespace is |
| * "http://www.w3.org/2000/xmlns" |
| * and ::qname is not prefixed |
| * "xmlns", |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not |
| * support the feature "XML" and the |
| * language exposed through the |
| * Document does not support |
| * Namespaces. |
| */ |
| dom_exception _dom_element_set_attribute_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *qname, |
| dom_string *value) |
| { |
| dom_exception err; |
| dom_string *localname; |
| dom_string *prefix; |
| if (_dom_validate_name(qname) == false) |
| return DOM_INVALID_CHARACTER_ERR; |
| err = _dom_namespace_validate_qname(qname, namespace); |
| if (err != DOM_NO_ERR) |
| return DOM_NAMESPACE_ERR; |
| err = _dom_namespace_split_qname(qname, &prefix, &localname); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* If there is no namespace, must have a prefix */ |
| if (namespace == NULL && prefix != NULL) { |
| dom_string_unref(prefix); |
| dom_string_unref(localname); |
| return DOM_NAMESPACE_ERR; |
| } |
| err = _dom_element_set_attr(element, namespace, localname, value); |
| dom_string_unref(prefix); |
| dom_string_unref(localname); |
| return err; |
| } |
| /** |
| * Remove an attribute from an element by namespace/localname |
| * |
| * \param element The element to remove attribute from |
| * \param namespace The attribute's namespace URI |
| * \param localname The attribute's local name |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly, |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not |
| * support the feature "XML" and the |
| * language exposed through the |
| * Document does not support |
| * Namespaces. |
| */ |
| dom_exception _dom_element_remove_attribute_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *localname) |
| { |
| return _dom_element_remove_attr(element, namespace, localname); |
| } |
| /** |
| * Retrieve an attribute node from an element by namespace/localname |
| * |
| * \param element The element to retrieve attribute from |
| * \param namespace The attribute's namespace URI |
| * \param localname The attribute's local name |
| * \param result Pointer to location to receive attribute node |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not support |
| * the feature "XML" and the language exposed |
| * through the Document does not support |
| * Namespaces. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_get_attribute_node_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *localname, |
| struct dom_attr **result) |
| { |
| return _dom_element_get_attr_node(element, namespace, localname, |
| result); |
| } |
| /** |
| * Set an attribute node on an element, replacing existing node, if present |
| * |
| * \param element The element to add a node to |
| * \param attr The attribute node to add |
| * \param result Pointer to location to recieve previous node |
| * \return DOM_NO_ERR on success, |
| * DOM_WRONG_DOCUMENT_ERR if ::attr does not belong to the |
| * same document as ::element, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly, |
| * DOM_INUSE_ATTRIBUTE_ERR if ::attr is already an attribute |
| * of another Element node. |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not |
| * support the feature "XML" and the |
| * language exposed through the |
| * Document does not support |
| * Namespaces. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_set_attribute_node_ns(struct dom_element *element, |
| struct dom_attr *attr, struct dom_attr **result) |
| { |
| dom_exception err; |
| dom_string *namespace; |
| err = dom_node_get_namespace(attr, (void *) &namespace); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_element_set_attr_node(element, namespace, attr, result); |
| if (namespace != NULL) |
| dom_string_unref(namespace); |
| return err; |
| } |
| /** |
| * Retrieve a list of descendant elements of an element which match a given |
| * namespace/localname pair. |
| * |
| * \param element The root of the subtree to search |
| * \param namespace The namespace URI to match (or "*" for all) |
| * \param localname The local name to match (or "*" for all) |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not support |
| * the feature "XML" and the language exposed |
| * through the Document does not support |
| * Namespaces. |
| * |
| * The returned nodelist will have its reference count increased. It is |
| * the responsibility of the caller to unref the nodelist once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_get_elements_by_tag_name_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *localname, struct dom_nodelist **result) |
| { |
| dom_exception err; |
| /** \todo ensure XML feature is supported */ |
| err = _dom_document_get_nodelist(element->base.owner, |
| DOM_NODELIST_BY_NAMESPACE, |
| (struct dom_node_internal *) element, NULL, |
| namespace, localname, |
| result); |
| return err; |
| } |
| /** |
| * Determine if an element possesses and attribute with the given name |
| * |
| * \param element The element to query |
| * \param name The attribute name to look for |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_element_has_attribute(struct dom_element *element, |
| dom_string *name, bool *result) |
| { |
| return _dom_element_has_attr(element, NULL, name, result); |
| } |
| /** |
| * Determine if an element possesses and attribute with the given |
| * namespace/localname pair. |
| * |
| * \param element The element to query |
| * \param namespace The attribute namespace URI to look for |
| * \param localname The attribute local name to look for |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not support |
| * the feature "XML" and the language exposed |
| * through the Document does not support |
| * Namespaces. |
| */ |
| dom_exception _dom_element_has_attribute_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *localname, |
| bool *result) |
| { |
| return _dom_element_has_attr(element, namespace, localname, result); |
| } |
| /** |
| * Retrieve the type information associated with an element |
| * |
| * \param element The element to retrieve type information from |
| * \param result Pointer to location to receive type information |
| * \return DOM_NO_ERR. |
| * |
| * The returned typeinfo will have its reference count increased. It is |
| * the responsibility of the caller to unref the typeinfo once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_get_schema_type_info(struct dom_element *element, |
| struct dom_type_info **result) |
| { |
| UNUSED(element); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * (Un)declare an attribute as being an element's ID by name |
| * |
| * \param element The element containing the attribute |
| * \param name The attribute's name |
| * \param is_id Whether the attribute is an ID |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly, |
| * DOM_NOT_FOUND_ERR if the specified node is not an |
| * attribute of ::element. |
| * |
| * @note: The DOM spec does not say: how to deal with when there are two or |
| * more isId attribute nodes. Here, the implementation just maintain only |
| * one such attribute node. |
| */ |
| dom_exception _dom_element_set_id_attribute(struct dom_element *element, |
| dom_string *name, bool is_id) |
| { |
| return _dom_element_set_id_attr(element, NULL, name, is_id); |
| } |
| /** |
| * (Un)declare an attribute as being an element's ID by namespace/localname |
| * |
| * \param element The element containing the attribute |
| * \param namespace The attribute's namespace URI |
| * \param localname The attribute's local name |
| * \param is_id Whether the attribute is an ID |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly, |
| * DOM_NOT_FOUND_ERR if the specified node is not an |
| * attribute of ::element. |
| */ |
| dom_exception _dom_element_set_id_attribute_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *localname, |
| bool is_id) |
| { |
| dom_exception err; |
| err = _dom_element_set_id_attr(element, namespace, localname, is_id); |
| element->id_ns = dom_string_ref(namespace); |
| return err; |
| } |
| /** |
| * (Un)declare an attribute node as being an element's ID |
| * |
| * \param element The element containing the attribute |
| * \param id_attr The attribute node |
| * \param is_id Whether the attribute is an ID |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly, |
| * DOM_NOT_FOUND_ERR if the specified node is not an |
| * attribute of ::element. |
| */ |
| dom_exception _dom_element_set_id_attribute_node(struct dom_element *element, |
| struct dom_attr *id_attr, bool is_id) |
| { |
| dom_exception err; |
| dom_string *namespace; |
| dom_string *localname; |
| err = dom_node_get_namespace(id_attr, &namespace); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_node_get_local_name(id_attr, &localname); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_element_set_id_attr(element, namespace, localname, is_id); |
| if (err != DOM_NO_ERR) |
| return err; |
| element->id_ns = namespace; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Obtain a pre-parsed array of class names for an element |
| * |
| * \param element Element containing classes |
| * \param classes Pointer to location to receive client-owned allocated array |
| * \param n_classes Pointer to location to receive number of classes |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEM_ERR on memory exhaustion |
| */ |
| dom_exception _dom_element_get_classes(struct dom_element *element, |
| lwc_string ***classes, uint32_t *n_classes) |
| { |
| if (element->n_classes > 0) { |
| lwc_string **classes_copy = NULL; |
| uint32_t classnr; |
| classes_copy = malloc(sizeof(lwc_string *) * |
| element->n_classes); |
| if (classes_copy == NULL) |
| return DOM_NO_MEM_ERR; |
| for (classnr = 0; classnr < element->n_classes; classnr++) |
| classes_copy[classnr] = lwc_string_ref( |
| element->classes[classnr]); |
| *classes = classes_copy; |
| *n_classes = element->n_classes; |
| } else { |
| *n_classes = 0; |
| *classes = NULL; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Determine if an element has an associated class |
| * |
| * \param element Element to consider |
| * \param name Class name to look for |
| * \param match Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_element_has_class(struct dom_element *element, |
| lwc_string *name, bool *match) |
| { |
| dom_exception err; |
| unsigned int class; |
| struct dom_node_internal *node = (struct dom_node_internal *)element; |
| dom_document_quirks_mode quirks_mode; |
| /* Short-circuit case where we have no classes */ |
| if (element->n_classes == 0) { |
| *match = false; |
| return DOM_NO_ERR; |
| } |
| err = dom_document_get_quirks_mode(node->owner, &quirks_mode); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (quirks_mode != DOM_DOCUMENT_QUIRKS_MODE_NONE) { |
| /* Quirks mode: case insensitively match */ |
| for (class = 0; class < element->n_classes; class++) { |
| if (lwc_error_ok == lwc_string_caseless_isequal(name, |
| element->classes[class], match) && |
| *match == true) |
| return DOM_NO_ERR; |
| } |
| } else { |
| /* Standards mode: case sensitively match */ |
| for (class = 0; class < element->n_classes; class++) { |
| if (lwc_error_ok == lwc_string_isequal(name, |
| element->classes[class], match) && |
| *match == true) |
| return DOM_NO_ERR; |
| } |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get a named ancestor node |
| * |
| * \param element Element to consider |
| * \param name Node name to look for |
| * \param ancestor Pointer to location to receive node pointer |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception dom_element_named_ancestor_node(dom_element *element, |
| lwc_string *name, dom_element **ancestor) |
| { |
| dom_node_internal *node = (dom_node_internal *)element; |
| *ancestor = NULL; |
| for (node = node->parent; node != NULL; node = node->parent) { |
| if (node->type != DOM_ELEMENT_NODE) |
| continue; |
| assert(node->name != NULL); |
| if (dom_string_caseless_lwc_isequal(node->name, name)) { |
| *ancestor = (dom_element *)node; |
| break; |
| } |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get a named parent node |
| * |
| * \param element Element to consider |
| * \param name Node name to look for |
| * \param parent Pointer to location to receive node pointer |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception dom_element_named_parent_node(dom_element *element, |
| lwc_string *name, dom_element **parent) |
| { |
| dom_node_internal *node = (dom_node_internal *)element; |
| *parent = NULL; |
| for (node = node->parent; node != NULL; node = node->parent) { |
| if (node->type != DOM_ELEMENT_NODE) |
| continue; |
| assert(node->name != NULL); |
| if (dom_string_caseless_lwc_isequal(node->name, name)) { |
| *parent = (dom_element *)node; |
| } |
| break; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get a named parent node |
| * |
| * \param element Element to consider |
| * \param name Node name to look for |
| * \param parent Pointer to location to receive node pointer |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception dom_element_parent_node(dom_element *element, |
| dom_element **parent) |
| { |
| dom_node_internal *node = (dom_node_internal *)element; |
| *parent = NULL; |
| for (node = node->parent; node != NULL; node = node->parent) { |
| if (node->type != DOM_ELEMENT_NODE) |
| continue; |
| *parent = (dom_element *)node; |
| break; |
| } |
| return DOM_NO_ERR; |
| } |
| /*------------- The overload virtual functions ------------------------*/ |
| /* Overload function of Node, please refer src/core/node.c for detail */ |
| dom_exception _dom_element_get_attributes(dom_node_internal *node, |
| struct dom_namednodemap **result) |
| { |
| dom_exception err; |
| dom_document *doc; |
| doc = dom_node_get_owner(node); |
| assert(doc != NULL); |
| err = _dom_namednodemap_create(doc, node, &attributes_opt, result); |
| if (err != DOM_NO_ERR) |
| return err; |
| dom_node_ref(node); |
| return DOM_NO_ERR; |
| } |
| /* Overload function of Node, please refer src/core/node.c for detail */ |
| dom_exception _dom_element_has_attributes(dom_node_internal *node, bool *result) |
| { |
| UNUSED(node); |
| *result = true; |
| return DOM_NO_ERR; |
| } |
| /* For the following namespace related algorithm take a look at: |
| * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html |
| */ |
| /** |
| * Look up the prefix which matches the namespace. |
| * |
| * \param node The current Node in which we search for |
| * \param namespace The namespace for which we search a prefix |
| * \param result The returned prefix |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_element_lookup_prefix(dom_node_internal *node, |
| dom_string *namespace, dom_string **result) |
| { |
| struct dom_element *owner; |
| dom_exception err; |
| err = dom_attr_get_owner_element(node, &owner); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (owner == NULL) { |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| return dom_node_lookup_prefix(owner, namespace, result); |
| } |
| /** |
| * Test whether certain namespace is the default namespace of some node. |
| * |
| * \param node The Node to test |
| * \param namespace The namespace to test |
| * \param result true is the namespace is default namespace |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_element_is_default_namespace(dom_node_internal *node, |
| dom_string *namespace, bool *result) |
| { |
| struct dom_element *ele = (struct dom_element *) node; |
| dom_string *value; |
| dom_exception err; |
| bool has; |
| dom_string *xmlns; |
| if (node->prefix == NULL) { |
| *result = dom_string_isequal(node->namespace, namespace); |
| return DOM_NO_ERR; |
| } |
| xmlns = _dom_namespace_get_xmlns_prefix(); |
| err = dom_element_has_attribute(ele, xmlns, &has); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (has == true) { |
| err = dom_element_get_attribute(ele, xmlns, &value); |
| if (err != DOM_NO_ERR) |
| return err; |
| *result = dom_string_isequal(value, namespace); |
| dom_string_unref(value); |
| return DOM_NO_ERR; |
| } |
| return dom_node_is_default_namespace(node->parent, namespace, result); |
| } |
| /** |
| * Look up the namespace with certain prefix. |
| * |
| * \param node The current node in which we search for the prefix |
| * \param prefix The prefix to search |
| * \param result The result namespace if found |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_element_lookup_namespace(dom_node_internal *node, |
| dom_string *prefix, dom_string **result) |
| { |
| dom_exception err; |
| bool has; |
| dom_string *xmlns; |
| if (node->namespace != NULL && |
| dom_string_isequal(node->prefix, prefix)) { |
| *result = dom_string_ref(node->namespace); |
| return DOM_NO_ERR; |
| } |
| xmlns = _dom_namespace_get_xmlns_prefix(); |
| err = dom_element_has_attribute_ns(node, xmlns, prefix, &has); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (has == true) |
| return dom_element_get_attribute_ns(node, |
| dom_namespaces[DOM_NAMESPACE_XMLNS], prefix, |
| result); |
| err = dom_element_has_attribute(node, xmlns, &has); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (has == true) { |
| return dom_element_get_attribute(node, xmlns, result); |
| } |
| return dom_node_lookup_namespace(node->parent, prefix, result); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /** |
| * The virtual function to parse some dom attribute |
| * |
| * \param ele The element object |
| * \param name The name of the attribute |
| * \param value The new value of the attribute |
| * \param parsed The parsed value of the attribute |
| * \return DOM_NO_ERR on success. |
| * |
| * @note: This virtual method is provided to serve as a template method. |
| * When any attribute is set or added, the attribute's value should be |
| * checked to make sure that it is a valid one. And the child class of |
| * dom_element may to do some special stuff on the attribute is set. Take |
| * some integer attribute as example: |
| * |
| * 1. The client call dom_element_set_attribute("size", "10.1"), but the |
| * size attribute may only accept an integer, and only the specific |
| * dom_element know this. And the dom_attr_set_value method, which is |
| * called by dom_element_set_attribute should call the this virtual |
| * template method. |
| * 2. The overload virtual function of following one will truncate the |
| * "10.1" to "10" to make sure it is a integer. And of course, the |
| * overload method may also save the integer as a 'int' C type for |
| * later easy accessing by any client. |
| */ |
| dom_exception _dom_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The destroy virtual function of dom_element */ |
| void __dom_element_destroy(struct dom_node_internal *node) |
| { |
| _dom_element_destroy((struct dom_element *) node); |
| } |
| /* TODO: How to deal with default attribue: |
| * |
| * Ask a language binding for default attributes. |
| * |
| * So, when we copy a element we copy all its attributes because they |
| * are all specified. For the methods like importNode and adoptNode, |
| * this will make _dom_element_copy can be used in them. |
| */ |
| dom_exception _dom_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| dom_element *olde = (dom_element *) old; |
| dom_element *e; |
| dom_exception err; |
| uint32_t classnr; |
| e = malloc(sizeof(dom_element)); |
| if (e == NULL) |
| return DOM_NO_MEM_ERR; |
| err = dom_node_copy_internal(old, e); |
| if (err != DOM_NO_ERR) { |
| free(e); |
| return err; |
| } |
| if (olde->attributes != NULL) { |
| /* Copy the attribute list */ |
| e->attributes = _dom_element_attr_list_clone(olde->attributes, |
| e); |
| } else { |
| e->attributes = NULL; |
| } |
| if (olde->n_classes > 0) { |
| e->n_classes = olde->n_classes; |
| e->classes = malloc(sizeof(lwc_string *) * e->n_classes); |
| for (classnr = 0; classnr < e->n_classes; ++classnr) |
| e->classes[classnr] = |
| lwc_string_ref(olde->classes[classnr]); |
| } else { |
| e->n_classes = 0; |
| e->classes = NULL; |
| } |
| e->id_ns = NULL; |
| e->id_name = NULL; |
| /* TODO: deal with dom_type_info, it get no definition ! */ |
| *copy = (dom_node_internal *) e; |
| return DOM_NO_ERR; |
| } |
| /*--------------------------------------------------------------------------*/ |
| /* Helper functions */ |
| /** |
| * The internal helper function for getAttribute/getAttributeNS. |
| * |
| * \param element The element |
| * \param namespace The namespace to look for attribute in. May be NULL. |
| * \param name The name of the attribute |
| * \param value The value of the attribute |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_element_get_attr(struct dom_element *element, |
| dom_string *namespace, dom_string *name, dom_string **value) |
| { |
| dom_attr_list *match; |
| dom_exception err = DOM_NO_ERR; |
| match = _dom_element_attr_list_find_by_name(element->attributes, |
| name, namespace); |
| /* Fill in value */ |
| if (match == NULL) { |
| *value = NULL; |
| } else { |
| err = dom_attr_get_value(match->attr, value); |
| } |
| return err; |
| } |
| /** |
| * The internal helper function for setAttribute and setAttributeNS. |
| * |
| * \param element The element |
| * \param namespace The namespace to set attribute for. May be NULL. |
| * \param name The name of the new attribute |
| * \param value The value of the new attribute |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_element_set_attr(struct dom_element *element, |
| dom_string *namespace, dom_string *name, dom_string *value) |
| { |
| dom_attr_list *match; |
| dom_node_internal *e = (dom_node_internal *) element; |
| dom_exception err; |
| if (_dom_validate_name(name) == false) |
| return DOM_INVALID_CHARACTER_ERR; |
| /* Ensure element can be written */ |
| if (_dom_node_readonly(e)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| match = _dom_element_attr_list_find_by_name(element->attributes, |
| name, namespace); |
| if (match != NULL) { |
| /* Found an existing attribute, so replace its value */ |
| /* Dispatch a DOMAttrModified event */ |
| dom_string *old = NULL; |
| struct dom_document *doc = dom_node_get_owner(element); |
| bool success = true; |
| err = dom_attr_get_value(match->attr, &old); |
| /* TODO: We did not support some node type such as entity |
| * reference, in that case, we should ignore the error to |
| * make sure the event model work as excepted. */ |
| if (err != DOM_NO_ERR && err != DOM_NOT_SUPPORTED_ERR) |
| return err; |
| err = _dom_dispatch_attr_modified_event(doc, e, old, value, |
| match->attr, name, DOM_MUTATION_MODIFICATION, |
| &success); |
| dom_string_unref(old); |
| if (err != DOM_NO_ERR) |
| return err; |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(doc, |
| (dom_event_target *) e, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_attr_set_value(match->attr, value); |
| if (err != DOM_NO_ERR) |
| return err; |
| } else { |
| /* No existing attribute, so create one */ |
| struct dom_attr *attr; |
| struct dom_attr_list *list_node; |
| struct dom_document *doc; |
| bool success = true; |
| err = _dom_attr_create(e->owner, name, namespace, NULL, |
| true, &attr); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* Set its parent, so that value parsing works */ |
| dom_node_set_parent(attr, element); |
| /* Set its value */ |
| err = dom_attr_set_value(attr, value); |
| if (err != DOM_NO_ERR) { |
| dom_node_set_parent(attr, NULL); |
| dom_node_unref(attr); |
| return err; |
| } |
| /* Dispatch a DOMAttrModified event */ |
| doc = dom_node_get_owner(element); |
| err = _dom_dispatch_attr_modified_event(doc, e, NULL, value, |
| (dom_event_target *) attr, name, |
| DOM_MUTATION_ADDITION, &success); |
| if (err != DOM_NO_ERR) { |
| dom_node_set_parent(attr, NULL); |
| dom_node_unref(attr); |
| return err; |
| } |
| err = dom_node_dispatch_node_change_event(doc, |
| attr, element, DOM_MUTATION_ADDITION, &success); |
| if (err != DOM_NO_ERR) { |
| dom_node_set_parent(attr, NULL); |
| dom_node_unref(attr); |
| return err; |
| } |
| /* Create attribute list node */ |
| list_node = _dom_element_attr_list_node_create(attr, element, |
| name, namespace); |
| if (list_node == NULL) { |
| /* If we failed at this step, there must be no memory */ |
| dom_node_set_parent(attr, NULL); |
| dom_node_unref(attr); |
| return DOM_NO_MEM_ERR; |
| } |
| dom_string_ref(name); |
| dom_string_ref(namespace); |
| /* Link into element's attribute list */ |
| if (element->attributes == NULL) |
| element->attributes = list_node; |
| else |
| _dom_element_attr_list_insert(element->attributes, |
| list_node); |
| dom_node_unref(attr); |
| dom_node_remove_pending(attr); |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(doc, |
| (dom_event_target *) element, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Remove an attribute from an element by name |
| * |
| * \param element The element to remove attribute from |
| * \param name The name of the attribute to remove |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly. |
| */ |
| dom_exception _dom_element_remove_attr(struct dom_element *element, |
| dom_string *namespace, dom_string *name) |
| { |
| dom_attr_list *match; |
| dom_exception err; |
| dom_node_internal *e = (dom_node_internal *) element; |
| /* Ensure element can be written to */ |
| if (_dom_node_readonly(e)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| match = _dom_element_attr_list_find_by_name(element->attributes, |
| name, namespace); |
| /* Detach attr node from list */ |
| if (match != NULL) { |
| /* Disptach DOMNodeRemoval event */ |
| bool success = true; |
| dom_attr *a = match->attr; |
| struct dom_document *doc = dom_node_get_owner(element); |
| dom_string *old = NULL; |
| err = dom_node_dispatch_node_change_event(doc, match->attr, |
| element, DOM_MUTATION_REMOVAL, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* Claim a reference for later event dispatch */ |
| dom_node_ref(a); |
| /* Delete the attribute node */ |
| if (element->attributes == match) { |
| element->attributes = |
| _dom_element_attr_list_next(match); |
| } |
| if (element->attributes == match) { |
| /* match must be sole attribute */ |
| element->attributes = NULL; |
| } |
| _dom_element_attr_list_node_unlink(match); |
| _dom_element_attr_list_node_destroy(match); |
| /* Dispatch a DOMAttrModified event */ |
| success = true; |
| err = dom_attr_get_value(a, &old); |
| /* TODO: We did not support some node type such as entity |
| * reference, in that case, we should ignore the error to |
| * make sure the event model work as excepted. */ |
| if (err != DOM_NO_ERR && err != DOM_NOT_SUPPORTED_ERR) |
| return err; |
| err = _dom_dispatch_attr_modified_event(doc, e, old, NULL, a, |
| name, DOM_MUTATION_REMOVAL, &success); |
| dom_string_unref(old); |
| /* Release the reference */ |
| dom_node_unref(a); |
| if (err != DOM_NO_ERR) |
| return err; |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(doc, |
| (dom_event_target *) e, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| /** \todo defaulted attribute handling */ |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve an attribute node from an element by name |
| * |
| * \param element The element to retrieve attribute node from |
| * \param name The attribute's name |
| * \param result Pointer to location to receive attribute node |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_get_attr_node(struct dom_element *element, |
| dom_string *namespace, dom_string *name, |
| struct dom_attr **result) |
| { |
| dom_attr_list *match; |
| match = _dom_element_attr_list_find_by_name(element->attributes, |
| name, namespace); |
| /* Fill in value */ |
| if (match == NULL) { |
| *result = NULL; |
| } else { |
| *result = match->attr; |
| dom_node_ref(*result); |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set an attribute node on an element, replacing existing node, if present |
| * |
| * \param element The element to add a node to |
| * \param attr The attribute node to add |
| * \param result Pointer to location to receive previous node |
| * \return DOM_NO_ERR on success, |
| * DOM_WRONG_DOCUMENT_ERR if ::attr does not belong to the |
| * same document as ::element, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly, |
| * DOM_INUSE_ATTRIBUTE_ERR if ::attr is already an attribute |
| * of another Element node. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_set_attr_node(struct dom_element *element, |
| dom_string *namespace, struct dom_attr *attr, |
| struct dom_attr **result) |
| { |
| dom_attr_list *match; |
| dom_exception err; |
| dom_string *name = NULL; |
| dom_node_internal *e = (dom_node_internal *) element; |
| dom_node_internal *attr_node = (dom_node_internal *) attr; |
| dom_attr *old_attr; |
| dom_string *new = NULL; |
| struct dom_document *doc; |
| bool success = true; |
| /** \todo validate name */ |
| /* Ensure element and attribute belong to the same document */ |
| if (e->owner != attr_node->owner) |
| return DOM_WRONG_DOCUMENT_ERR; |
| /* Ensure element can be written to */ |
| if (_dom_node_readonly(e)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| /* Ensure attribute isn't attached to another element */ |
| if (attr_node->parent != NULL && attr_node->parent != e) |
| return DOM_INUSE_ATTRIBUTE_ERR; |
| err = dom_node_get_local_name(attr, &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| match = _dom_element_attr_list_find_by_name(element->attributes, |
| name, namespace); |
| *result = NULL; |
| if (match != NULL) { |
| /* Disptach DOMNodeRemoval event */ |
| dom_string *old = NULL; |
| doc = dom_node_get_owner(element); |
| old_attr = match->attr; |
| err = dom_node_dispatch_node_change_event(doc, old_attr, |
| element, DOM_MUTATION_REMOVAL, &success); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(name); |
| return err; |
| } |
| dom_node_ref(old_attr); |
| _dom_element_attr_list_node_unlink(match); |
| _dom_element_attr_list_node_destroy(match); |
| /* Dispatch a DOMAttrModified event */ |
| success = true; |
| err = dom_attr_get_value(old_attr, &old); |
| /* TODO: We did not support some node type such as entity |
| * reference, in that case, we should ignore the error to |
| * make sure the event model work as excepted. */ |
| if (err != DOM_NO_ERR && err != DOM_NOT_SUPPORTED_ERR) { |
| dom_node_unref(old_attr); |
| dom_string_unref(name); |
| return err; |
| } |
| err = _dom_dispatch_attr_modified_event(doc, e, old, NULL, |
| (dom_event_target *) old_attr, name, |
| DOM_MUTATION_REMOVAL, &success); |
| dom_string_unref(old); |
| *result = old_attr; |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(name); |
| return err; |
| } |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(doc, |
| (dom_event_target *) e, &success); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(name); |
| return err; |
| } |
| } |
| match = _dom_element_attr_list_node_create(attr, element, |
| name, namespace); |
| if (match == NULL) { |
| dom_string_unref(name); |
| /* If we failed at this step, there must be no memory */ |
| return DOM_NO_MEM_ERR; |
| } |
| dom_string_ref(name); |
| dom_string_ref(namespace); |
| dom_node_set_parent(attr, element); |
| dom_node_remove_pending(attr); |
| /* Dispatch a DOMAttrModified event */ |
| doc = dom_node_get_owner(element); |
| success = true; |
| err = dom_attr_get_value(attr, &new); |
| /* TODO: We did not support some node type such as entity reference, in |
| * that case, we should ignore the error to make sure the event model |
| * work as excepted. */ |
| if (err != DOM_NO_ERR && err != DOM_NOT_SUPPORTED_ERR) |
| return err; |
| err = _dom_dispatch_attr_modified_event(doc, e, NULL, new, |
| (dom_event_target *) attr, name, |
| DOM_MUTATION_ADDITION, &success); |
| /* Cleanup */ |
| dom_string_unref(new); |
| dom_string_unref(name); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| err = dom_node_dispatch_node_change_event(doc, attr, element, |
| DOM_MUTATION_ADDITION, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(doc, |
| (dom_event_target *) element, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* Link into element's attribute list */ |
| if (element->attributes == NULL) |
| element->attributes = match; |
| else |
| _dom_element_attr_list_insert(element->attributes, match); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Remove an attribute node from an element |
| * |
| * \param element The element to remove attribute node from |
| * \param attr The attribute node to remove |
| * \param result Pointer to location to receive attribute node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::element is readonly, |
| * DOM_NOT_FOUND_ERR if ::attr is not an attribute of |
| * ::element. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_element_remove_attr_node(struct dom_element *element, |
| dom_string *namespace, struct dom_attr *attr, |
| struct dom_attr **result) |
| { |
| dom_attr_list *match; |
| dom_exception err; |
| dom_string *name; |
| dom_node_internal *e = (dom_node_internal *) element; |
| dom_attr *a; |
| bool success = true; |
| struct dom_document *doc; |
| dom_string *old = NULL; |
| /* Ensure element can be written to */ |
| if (_dom_node_readonly(e)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| err = dom_node_get_node_name(attr, &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| match = _dom_element_attr_list_find_by_name(element->attributes, |
| name, namespace); |
| /** \todo defaulted attribute handling */ |
| if (match == NULL || match->attr != attr) { |
| dom_string_unref(name); |
| return DOM_NOT_FOUND_ERR; |
| } |
| a = match->attr; |
| /* Dispatch a DOMNodeRemoved event */ |
| doc = dom_node_get_owner(element); |
| err = dom_node_dispatch_node_change_event(doc, a, element, |
| DOM_MUTATION_REMOVAL, &success); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(name); |
| return err; |
| } |
| dom_node_ref(a); |
| /* Delete the attribute node */ |
| if (element->attributes == match) { |
| element->attributes = _dom_element_attr_list_next(match); |
| } |
| if (element->attributes == match) { |
| /* match must be sole attribute */ |
| element->attributes = NULL; |
| } |
| _dom_element_attr_list_node_unlink(match); |
| _dom_element_attr_list_node_destroy(match); |
| /* Now, cleaup the dom_string */ |
| dom_string_unref(name); |
| /* Dispatch a DOMAttrModified event */ |
| success = true; |
| err = dom_attr_get_value(a, &old); |
| /* TODO: We did not support some node type such as entity reference, in |
| * that case, we should ignore the error to make sure the event model |
| * work as excepted. */ |
| if (err != DOM_NO_ERR && err != DOM_NOT_SUPPORTED_ERR) { |
| dom_node_unref(a); |
| return err; |
| } |
| err = _dom_dispatch_attr_modified_event(doc, e, old, NULL, |
| (dom_event_target *) a, name, |
| DOM_MUTATION_REMOVAL, &success); |
| dom_string_unref(old); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* When a Node is removed, it should be destroy. When its refcnt is not |
| * zero, it will be added to the document's deletion pending list. |
| * When a Node is removed, its parent should be NULL, but its owner |
| * should remain to be the document. |
| */ |
| *result = (dom_attr *) a; |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(doc, |
| (dom_event_target *) e, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Test whether certain attribute exists on the element |
| * |
| * \param element The element |
| * \param namespace The namespace to look for attribute in. May be NULL. |
| * \param name The attribute's name |
| * \param result The return value |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_element_has_attr(struct dom_element *element, |
| dom_string *namespace, dom_string *name, bool *result) |
| { |
| dom_attr_list *match; |
| match = _dom_element_attr_list_find_by_name(element->attributes, |
| name, namespace); |
| /* Fill in result */ |
| if (match == NULL) { |
| *result = false; |
| } else { |
| *result = true; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * (Un)set an attribute Node as a ID. |
| * |
| * \param element The element contains the attribute |
| * \param namespace The namespace of the attribute node |
| * \param name The name of the attribute |
| * \param is_id true for set the node as a ID attribute, false unset it |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_element_set_id_attr(struct dom_element *element, |
| dom_string *namespace, dom_string *name, bool is_id) |
| { |
| dom_attr_list *match; |
| match = _dom_element_attr_list_find_by_name(element->attributes, |
| name, namespace); |
| if (match == NULL) |
| return DOM_NOT_FOUND_ERR; |
| if (is_id == true) { |
| /* Clear the previous id attribute if there is one */ |
| dom_attr_list *old = _dom_element_attr_list_find_by_name( |
| element->attributes, element->id_name, |
| element->id_ns); |
| if (old != NULL) { |
| _dom_attr_set_isid(old->attr, false); |
| } |
| /* Set up the new id attr stuff */ |
| element->id_name = dom_string_ref(name); |
| element->id_ns = dom_string_ref(namespace); |
| } |
| _dom_attr_set_isid(match->attr, is_id); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the ID string of the element |
| * |
| * \param ele The element |
| * \param id The ID of this element |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_element_get_id(struct dom_element *ele, dom_string **id) |
| { |
| dom_exception err; |
| dom_string *ret = NULL; |
| dom_document *doc; |
| dom_string *name; |
| *id = NULL; |
| if (ele->id_ns != NULL && ele->id_name != NULL) { |
| /* There is user specific ID attribute */ |
| err = _dom_element_get_attribute_ns(ele, ele->id_ns, |
| ele->id_name, &ret); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| *id = ret; |
| return err; |
| } |
| doc = dom_node_get_owner(ele); |
| assert(doc != NULL); |
| if (ele->id_name != NULL) { |
| name = ele->id_name; |
| } else { |
| name = _dom_document_get_id_name(doc); |
| if (name == NULL) { |
| /* No ID attribute at all, just return NULL */ |
| *id = NULL; |
| return DOM_NO_ERR; |
| } |
| } |
| err = _dom_element_get_attribute(ele, name, &ret); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| if (ret != NULL) { |
| *id = ret; |
| } else { |
| *id = NULL; |
| } |
| return err; |
| } |
| /*-------------- The dom_namednodemap functions -------------------------*/ |
| /* Implementation function for NamedNodeMap, see core/namednodemap.h for |
| * details */ |
| dom_exception attributes_get_length(void *priv, uint32_t *length) |
| { |
| dom_element *e = (dom_element *) priv; |
| *length = _dom_element_attr_list_length(e->attributes); |
| return DOM_NO_ERR; |
| } |
| /* Implementation function for NamedNodeMap, see core/namednodemap.h for |
| * details */ |
| dom_exception attributes_get_named_item(void *priv, |
| dom_string *name, struct dom_node **node) |
| { |
| dom_element *e = (dom_element *) priv; |
| return _dom_element_get_attribute_node(e, name, (dom_attr **) node); |
| } |
| /* Implementation function for NamedNodeMap, see core/namednodemap.h for |
| * details */ |
| dom_exception attributes_set_named_item(void *priv, |
| struct dom_node *arg, struct dom_node **node) |
| { |
| dom_element *e = (dom_element *) priv; |
| dom_node_internal *n = (dom_node_internal *) arg; |
| if (n->type != DOM_ATTRIBUTE_NODE) |
| return DOM_HIERARCHY_REQUEST_ERR; |
| return _dom_element_set_attribute_node(e, (dom_attr *) arg, |
| (dom_attr **) node); |
| } |
| /* Implementation function for NamedNodeMap, see core/namednodemap.h for |
| * details */ |
| dom_exception attributes_remove_named_item( |
| void *priv, dom_string *name, |
| struct dom_node **node) |
| { |
| dom_element *e = (dom_element *) priv; |
| dom_exception err; |
| err = _dom_element_get_attribute_node(e, name, (dom_attr **) node); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (*node == NULL) { |
| return DOM_NOT_FOUND_ERR; |
| } |
| return _dom_element_remove_attribute(e, name); |
| } |
| /* Implementation function for NamedNodeMap, see core/namednodemap.h for |
| * details */ |
| dom_exception attributes_item(void *priv, |
| uint32_t index, struct dom_node **node) |
| { |
| dom_attr_list * match = NULL; |
| unsigned int num = index + 1; |
| dom_element *e = (dom_element *) priv; |
| match = _dom_element_attr_list_get_by_index(e->attributes, num); |
| if (match != NULL) { |
| *node = (dom_node *) match->attr; |
| dom_node_ref(*node); |
| } else { |
| *node = NULL; |
| } |
| return DOM_NO_ERR; |
| } |
| /* Implementation function for NamedNodeMap, see core/namednodemap.h for |
| * details */ |
| dom_exception attributes_get_named_item_ns( |
| void *priv, dom_string *namespace, |
| dom_string *localname, struct dom_node **node) |
| { |
| dom_element *e = (dom_element *) priv; |
| return _dom_element_get_attribute_node_ns(e, namespace, localname, |
| (dom_attr **) node); |
| } |
| /* Implementation function for NamedNodeMap, see core/namednodemap.h for |
| * details */ |
| dom_exception attributes_set_named_item_ns( |
| void *priv, struct dom_node *arg, |
| struct dom_node **node) |
| { |
| dom_element *e = (dom_element *) priv; |
| dom_node_internal *n = (dom_node_internal *) arg; |
| if (n->type != DOM_ATTRIBUTE_NODE) |
| return DOM_HIERARCHY_REQUEST_ERR; |
| return _dom_element_set_attribute_node_ns(e, (dom_attr *) arg, |
| (dom_attr **) node); |
| } |
| /* Implementation function for NamedNodeMap, see core/namednodemap.h for |
| * details */ |
| dom_exception attributes_remove_named_item_ns( |
| void *priv, dom_string *namespace, |
| dom_string *localname, struct dom_node **node) |
| { |
| dom_element *e = (dom_element *) priv; |
| dom_exception err; |
| err = _dom_element_get_attribute_node_ns(e, namespace, localname, |
| (dom_attr **) node); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (*node == NULL) { |
| return DOM_NOT_FOUND_ERR; |
| } |
| return _dom_element_remove_attribute_ns(e, namespace, localname); |
| } |
| /* Implementation function for NamedNodeMap, see core/namednodemap.h for |
| * details */ |
| void attributes_destroy(void *priv) |
| { |
| dom_element *e = (dom_element *) priv; |
| dom_node_unref(e); |
| } |
| /* Implementation function for NamedNodeMap, see core/namednodemap.h for |
| * details */ |
| bool attributes_equal(void *p1, void *p2) |
| { |
| /* We have passed the pointer to this element as the private data, |
| * and here we just need to compare whether the two elements are |
| * equal |
| */ |
| return p1 == p2; |
| } |
| /*------------------ End of namednodemap functions -----------------------*/ |
| /contrib/network/netsurf/libdom/src/core/element.h |
|---|
| 0,0 → 1,238 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_element_h_ |
| #define dom_internal_core_element_h_ |
| #include <stdbool.h> |
| #include <dom/core/element.h> |
| #include "core/node.h" |
| struct dom_document; |
| struct dom_element; |
| struct dom_namednodemap; |
| struct dom_node; |
| struct dom_attr; |
| struct dom_attr_list; |
| struct dom_type_info; |
| struct dom_hash_table; |
| /** |
| * DOM element node |
| */ |
| struct dom_element { |
| struct dom_node_internal base; /**< Base node */ |
| struct dom_attr_list *attributes; /**< Element attributes */ |
| dom_string *id_ns; /**< The id attribute's namespace */ |
| dom_string *id_name; /**< The id attribute's name */ |
| struct dom_type_info *schema_type_info; /**< Type information */ |
| lwc_string **classes; |
| uint32_t n_classes; |
| }; |
| dom_exception _dom_element_create(struct dom_document *doc, |
| dom_string *name, dom_string *namespace, |
| dom_string *prefix, struct dom_element **result); |
| dom_exception _dom_element_initialise(struct dom_document *doc, |
| struct dom_element *el, dom_string *name, |
| dom_string *namespace, dom_string *prefix); |
| void _dom_element_finalise(struct dom_element *ele); |
| void _dom_element_destroy(struct dom_element *element); |
| /* The virtual functions of dom_element */ |
| dom_exception _dom_element_get_tag_name(struct dom_element *element, |
| dom_string **name); |
| dom_exception _dom_element_get_attribute(struct dom_element *element, |
| dom_string *name, dom_string **value); |
| dom_exception _dom_element_set_attribute(struct dom_element *element, |
| dom_string *name, dom_string *value); |
| dom_exception _dom_element_remove_attribute(struct dom_element *element, |
| dom_string *name); |
| dom_exception _dom_element_get_attribute_node(struct dom_element *element, |
| dom_string *name, struct dom_attr **result); |
| dom_exception _dom_element_set_attribute_node(struct dom_element *element, |
| struct dom_attr *attr, struct dom_attr **result); |
| dom_exception _dom_element_remove_attribute_node(struct dom_element *element, |
| struct dom_attr *attr, struct dom_attr **result); |
| dom_exception _dom_element_get_elements_by_tag_name( |
| struct dom_element *element, dom_string *name, |
| struct dom_nodelist **result); |
| dom_exception _dom_element_get_attribute_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *localname, |
| dom_string **value); |
| dom_exception _dom_element_set_attribute_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *qname, |
| dom_string *value); |
| dom_exception _dom_element_remove_attribute_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *localname); |
| dom_exception _dom_element_get_attribute_node_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *localname, |
| struct dom_attr **result); |
| dom_exception _dom_element_set_attribute_node_ns(struct dom_element *element, |
| struct dom_attr *attr, struct dom_attr **result); |
| dom_exception _dom_element_get_elements_by_tag_name_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *localname, struct dom_nodelist **result); |
| dom_exception _dom_element_has_attribute(struct dom_element *element, |
| dom_string *name, bool *result); |
| dom_exception _dom_element_has_attribute_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *localname, |
| bool *result); |
| dom_exception _dom_element_get_schema_type_info(struct dom_element *element, |
| struct dom_type_info **result); |
| dom_exception _dom_element_set_id_attribute(struct dom_element *element, |
| dom_string *name, bool is_id); |
| dom_exception _dom_element_set_id_attribute_ns(struct dom_element *element, |
| dom_string *namespace, dom_string *localname, |
| bool is_id); |
| dom_exception _dom_element_set_id_attribute_node(struct dom_element *element, |
| struct dom_attr *id_attr, bool is_id); |
| dom_exception _dom_element_get_classes(struct dom_element *element, |
| lwc_string ***classes, uint32_t *n_classes); |
| dom_exception _dom_element_has_class(struct dom_element *element, |
| lwc_string *name, bool *match); |
| #define DOM_ELEMENT_VTABLE \ |
| _dom_element_get_tag_name, \ |
| _dom_element_get_attribute, \ |
| _dom_element_set_attribute, \ |
| _dom_element_remove_attribute, \ |
| _dom_element_get_attribute_node, \ |
| _dom_element_set_attribute_node, \ |
| _dom_element_remove_attribute_node, \ |
| _dom_element_get_elements_by_tag_name, \ |
| _dom_element_get_attribute_ns, \ |
| _dom_element_set_attribute_ns, \ |
| _dom_element_remove_attribute_ns, \ |
| _dom_element_get_attribute_node_ns, \ |
| _dom_element_set_attribute_node_ns, \ |
| _dom_element_get_elements_by_tag_name_ns, \ |
| _dom_element_has_attribute, \ |
| _dom_element_has_attribute_ns, \ |
| _dom_element_get_schema_type_info, \ |
| _dom_element_set_id_attribute, \ |
| _dom_element_set_id_attribute_ns, \ |
| _dom_element_set_id_attribute_node, \ |
| _dom_element_get_classes, \ |
| _dom_element_has_class |
| /* Overloading dom_node functions */ |
| dom_exception _dom_element_get_attributes(dom_node_internal *node, |
| struct dom_namednodemap **result); |
| dom_exception _dom_element_has_attributes(dom_node_internal *node, |
| bool *result); |
| dom_exception _dom_element_normalize(dom_node_internal *node); |
| dom_exception _dom_element_lookup_prefix(dom_node_internal *node, |
| dom_string *namespace, dom_string **result); |
| dom_exception _dom_element_is_default_namespace(dom_node_internal *node, |
| dom_string *namespace, bool *result); |
| dom_exception _dom_element_lookup_namespace(dom_node_internal *node, |
| dom_string *prefix, dom_string **result); |
| #define DOM_NODE_VTABLE_ELEMENT \ |
| _dom_node_try_destroy, \ |
| _dom_node_get_node_name, \ |
| _dom_node_get_node_value, \ |
| _dom_node_set_node_value, \ |
| _dom_node_get_node_type, \ |
| _dom_node_get_parent_node, \ |
| _dom_node_get_child_nodes, \ |
| _dom_node_get_first_child, \ |
| _dom_node_get_last_child, \ |
| _dom_node_get_previous_sibling, \ |
| _dom_node_get_next_sibling, \ |
| _dom_element_get_attributes, /*overload*/\ |
| _dom_node_get_owner_document, \ |
| _dom_node_insert_before, \ |
| _dom_node_replace_child, \ |
| _dom_node_remove_child, \ |
| _dom_node_append_child, \ |
| _dom_node_has_child_nodes, \ |
| _dom_node_clone_node, \ |
| _dom_node_normalize, \ |
| _dom_node_is_supported, \ |
| _dom_node_get_namespace, \ |
| _dom_node_get_prefix, \ |
| _dom_node_set_prefix, \ |
| _dom_node_get_local_name, \ |
| _dom_element_has_attributes, /*overload*/\ |
| _dom_node_get_base, \ |
| _dom_node_compare_document_position, \ |
| _dom_node_get_text_content, \ |
| _dom_node_set_text_content, \ |
| _dom_node_is_same, \ |
| _dom_element_lookup_prefix, /*overload*/\ |
| _dom_element_is_default_namespace, /*overload*/\ |
| _dom_element_lookup_namespace, /*overload*/\ |
| _dom_node_is_equal, \ |
| _dom_node_get_feature, \ |
| _dom_node_set_user_data, \ |
| _dom_node_get_user_data |
| /** |
| * The internal used vtable for element |
| */ |
| struct dom_element_protected_vtable { |
| struct dom_node_protect_vtable base; |
| dom_exception (*dom_element_parse_attribute)(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| /**< Called by dom_attr_set_value, and used to check |
| * whether the new attribute value is valid and |
| * return a valid on if it is not |
| */ |
| }; |
| typedef struct dom_element_protected_vtable dom_element_protected_vtable; |
| /* Parse the attribute's value */ |
| static inline dom_exception dom_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| struct dom_node_internal *node = (struct dom_node_internal *) ele; |
| return ((dom_element_protected_vtable *) node->vtable)-> |
| dom_element_parse_attribute(ele, name, value, parsed); |
| } |
| #define dom_element_parse_attribute(e, n, v, p) dom_element_parse_attribute( \ |
| (dom_element *) (e), (dom_string *) (n), \ |
| (dom_string *) (v), (dom_string **) (p)) |
| /* The protected virtual function */ |
| dom_exception _dom_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void __dom_element_destroy(dom_node_internal *node); |
| dom_exception _dom_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_ELEMENT_PROTECT_VTABLE \ |
| _dom_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_ELEMENT \ |
| __dom_element_destroy, \ |
| _dom_element_copy |
| /* Helper functions*/ |
| dom_exception _dom_element_get_id(struct dom_element *ele, dom_string **id); |
| extern struct dom_element_vtable _dom_element_vtable; |
| #endif |
| /contrib/network/netsurf/libdom/src/core/entity_ref.c |
|---|
| 0,0 → 1,142 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "core/document.h" |
| #include "core/entity_ref.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| /** |
| * A DOM entity reference |
| */ |
| struct dom_entity_reference { |
| dom_node_internal base; /**< Base node */ |
| }; |
| static struct dom_node_vtable er_vtable = { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE |
| }, |
| DOM_NODE_VTABLE |
| }; |
| static struct dom_node_protect_vtable er_protect_vtable = { |
| DOM_ER_PROTECT_VTABLE |
| }; |
| /** |
| * Create an entity reference |
| * |
| * \param doc The owning document |
| * \param name The name of the node to create |
| * \param value The text content of the node |
| * \param result Pointer to location to receive created node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * ::doc, ::name and ::value will have their reference counts increased. |
| * |
| * The returned node will already be referenced. |
| */ |
| dom_exception _dom_entity_reference_create(dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_entity_reference **result) |
| { |
| dom_entity_reference *e; |
| dom_exception err; |
| /* Allocate the comment node */ |
| e = malloc(sizeof(dom_entity_reference)); |
| if (e == NULL) |
| return DOM_NO_MEM_ERR; |
| e->base.base.vtable = &er_vtable; |
| e->base.vtable = &er_protect_vtable; |
| /* And initialise the node */ |
| err = _dom_entity_reference_initialise(&e->base, doc, |
| DOM_ENTITY_REFERENCE_NODE, name, value, NULL, NULL); |
| if (err != DOM_NO_ERR) { |
| free(e); |
| return err; |
| } |
| *result = e; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Destroy an entity reference |
| * |
| * \param entity The entity reference to destroy |
| * |
| * The contents of ::entity will be destroyed and ::entity will be freed. |
| */ |
| void _dom_entity_reference_destroy(dom_entity_reference *entity) |
| { |
| /* Finalise base class */ |
| _dom_entity_reference_finalise(&entity->base); |
| /* Destroy fragment */ |
| free(entity); |
| } |
| /** |
| * Get the textual representation of an EntityRererence |
| * |
| * \param entity The entity reference to get the textual representation of |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unrer the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_entity_reference_get_textual_representation( |
| dom_entity_reference *entity, dom_string **result) |
| { |
| UNUSED(entity); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Following comes the protected vtable */ |
| /* The virtual destroy function of this class */ |
| void _dom_er_destroy(dom_node_internal *node) |
| { |
| _dom_entity_reference_destroy((dom_entity_reference *) node); |
| } |
| /* The copy constructor of this class */ |
| dom_exception _dom_er_copy(dom_node_internal *old, dom_node_internal **copy) |
| { |
| dom_entity_reference *new_er; |
| dom_exception err; |
| new_er = malloc(sizeof(dom_entity_reference)); |
| if (new_er == NULL) |
| return DOM_NO_MEM_ERR; |
| err = dom_node_copy_internal(old, new_er); |
| if (err != DOM_NO_ERR) { |
| free(new_er); |
| return err; |
| } |
| *copy = (dom_node_internal *) new_er; |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/core/entity_ref.h |
|---|
| 0,0 → 1,36 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_entityrererence_h_ |
| #define dom_internal_core_entityrererence_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/entity_ref.h> |
| dom_exception _dom_entity_reference_create(dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_entity_reference **result); |
| void _dom_entity_reference_destroy(dom_entity_reference *entity); |
| #define _dom_entity_reference_initialise _dom_node_initialise |
| #define _dom_entity_reference_finalise _dom_node_finalise |
| /* Following comes the protected vtable */ |
| void _dom_er_destroy(dom_node_internal *node); |
| dom_exception _dom_er_copy(dom_node_internal *old, dom_node_internal **copy); |
| #define DOM_ER_PROTECT_VTABLE \ |
| _dom_er_destroy, \ |
| _dom_er_copy |
| /* Helper functions */ |
| dom_exception _dom_entity_reference_get_textual_representation( |
| dom_entity_reference *entity, |
| dom_string **result); |
| #endif |
| /contrib/network/netsurf/libdom/src/core/implementation.c |
|---|
| 0,0 → 1,293 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #include <string.h> |
| #include <dom/core/implementation.h> |
| #include "core/document.h" |
| #include "core/document_type.h" |
| #include "html/html_document.h" |
| #include "utils/namespace.h" |
| #include "utils/utils.h" |
| #include "utils/validate.h" |
| /** |
| * Test whether a DOM implementation implements a specific feature |
| * and version |
| * |
| * \param feature The feature to test for |
| * \param version The version number of the feature to test for |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception dom_implementation_has_feature( |
| const char *feature, const char *version, |
| bool *result) |
| { |
| UNUSED(feature); |
| UNUSED(version); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Create a document type node |
| * |
| * \param qname The qualified name of the document type |
| * \param public_id The external subset public identifier |
| * \param system_id The external subset system identifier |
| * \param doctype Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::qname is invalid, |
| * DOM_NAMESPACE_ERR if ::qname is malformed, |
| * DOM_NOT_SUPPORTED_ERR if ::impl does not support the feature |
| * "XML" and the language exposed through |
| * Document does not support XML |
| * namespaces. |
| * |
| * The doctype will be referenced, so the client need not do this |
| * explicitly. The client must unref the doctype once it has |
| * finished with it. |
| */ |
| dom_exception dom_implementation_create_document_type( |
| const char *qname, const char *public_id, |
| const char *system_id, |
| struct dom_document_type **doctype) |
| { |
| struct dom_document_type *d; |
| dom_string *qname_s = NULL, *prefix = NULL, *lname = NULL; |
| dom_string *public_id_s = NULL, *system_id_s = NULL; |
| dom_exception err; |
| if (qname != NULL) { |
| err = dom_string_create((const uint8_t *) qname, |
| strlen(qname), &qname_s); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| err = _dom_namespace_split_qname(qname_s, &prefix, &lname); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(qname_s); |
| return err; |
| } |
| if (public_id != NULL) { |
| err = dom_string_create((const uint8_t *) public_id, |
| strlen(public_id), &public_id_s); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(lname); |
| dom_string_unref(prefix); |
| dom_string_unref(qname_s); |
| return err; |
| } |
| } |
| if (system_id != NULL) { |
| err = dom_string_create((const uint8_t *) system_id, |
| strlen(system_id), &system_id_s); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(public_id_s); |
| dom_string_unref(lname); |
| dom_string_unref(prefix); |
| dom_string_unref(qname_s); |
| return err; |
| } |
| } |
| /* Create the doctype */ |
| err = _dom_document_type_create(qname_s, public_id_s, system_id_s, &d); |
| if (err == DOM_NO_ERR) |
| *doctype = d; |
| dom_string_unref(system_id_s); |
| dom_string_unref(public_id_s); |
| dom_string_unref(prefix); |
| dom_string_unref(lname); |
| dom_string_unref(qname_s); |
| return err; |
| } |
| /** |
| * Create a document node |
| * |
| * \param impl_type The type of document object to create |
| * \param namespace The namespace URI of the document element |
| * \param qname The qualified name of the document element |
| * \param doctype The type of document to create |
| * \param doc Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if ::qname is invalid, |
| * DOM_NAMESPACE_ERR if ::qname is malformed, or if ::qname |
| * has a prefix and ::namespace is NULL, |
| * or if ::qname is NULL and ::namespace |
| * is non-NULL, or if ::qname has a prefix |
| * "xml" and ::namespace is not |
| * "http://www.w3.org/XML/1998/namespace", |
| * or if ::impl does not support the "XML" |
| * feature and ::namespace is non-NULL, |
| * DOM_WRONG_DOCUMENT_ERR if ::doctype is already being used by a |
| * document, or if it was not created by |
| * ::impl, |
| * DOM_NOT_SUPPORTED_ERR if ::impl does not support the feature |
| * "XML" and the language exposed through |
| * Document does not support XML |
| * namespaces. |
| * |
| * The document will be referenced, so the client need not do this |
| * explicitly. The client must unref the document once it has |
| * finished with it. |
| */ |
| dom_exception dom_implementation_create_document( |
| uint32_t impl_type, |
| const char *namespace, const char *qname, |
| struct dom_document_type *doctype, |
| dom_events_default_action_fetcher daf, |
| void *daf_ctx, |
| struct dom_document **doc) |
| { |
| struct dom_document *d; |
| dom_string *namespace_s = NULL, *qname_s = NULL; |
| dom_exception err; |
| if (namespace != NULL) { |
| err = dom_string_create((const uint8_t *) namespace, |
| strlen(namespace), &namespace_s); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| if (qname != NULL) { |
| err = dom_string_create((const uint8_t *) qname, |
| strlen(qname), &qname_s); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(namespace_s); |
| return err; |
| } |
| } |
| if (qname_s != NULL && _dom_validate_name(qname_s) == false) { |
| dom_string_unref(qname_s); |
| dom_string_unref(namespace_s); |
| return DOM_INVALID_CHARACTER_ERR; |
| } |
| err = _dom_namespace_validate_qname(qname_s, namespace_s); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(qname_s); |
| dom_string_unref(namespace_s); |
| return DOM_NAMESPACE_ERR; |
| } |
| if (doctype != NULL && dom_node_get_parent(doctype) != NULL) { |
| dom_string_unref(qname_s); |
| dom_string_unref(namespace_s); |
| return DOM_WRONG_DOCUMENT_ERR; |
| } |
| /* Create document object that reflects the required APIs */ |
| if (impl_type == DOM_IMPLEMENTATION_HTML) { |
| dom_html_document *html_doc; |
| err = _dom_html_document_create(daf, daf_ctx, &html_doc); |
| d = (dom_document *) html_doc; |
| } else { |
| err = _dom_document_create(daf, daf_ctx, &d); |
| } |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(qname_s); |
| dom_string_unref(namespace_s); |
| return err; |
| } |
| /* Set its doctype, if necessary */ |
| if (doctype != NULL) { |
| struct dom_node *ins_doctype = NULL; |
| err = dom_node_append_child((struct dom_node *) d, |
| (struct dom_node *) doctype, &ins_doctype); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) d); |
| dom_string_unref(qname_s); |
| dom_string_unref(namespace_s); |
| return err; |
| } |
| /* Not interested in inserted doctype */ |
| if (ins_doctype != NULL) |
| dom_node_unref(ins_doctype); |
| } |
| /* Create root element and attach it to document */ |
| if (qname_s != NULL) { |
| struct dom_element *e; |
| struct dom_node *inserted; |
| err = dom_document_create_element_ns(d, namespace_s, qname_s, &e); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) d); |
| dom_string_unref(qname_s); |
| dom_string_unref(namespace_s); |
| return err; |
| } |
| err = dom_node_append_child((struct dom_node *) d, |
| (struct dom_node *) e, &inserted); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref((struct dom_node *) e); |
| dom_node_unref((struct dom_node *) d); |
| dom_string_unref(qname_s); |
| dom_string_unref(namespace_s); |
| return err; |
| } |
| /* No int32_ter interested in inserted node */ |
| dom_node_unref(inserted); |
| /* Done with element */ |
| dom_node_unref((struct dom_node *) e); |
| } |
| /* Clean up strings we created */ |
| dom_string_unref(qname_s); |
| dom_string_unref(namespace_s); |
| *doc = d; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve a specialized object which implements the specified |
| * feature and version |
| * |
| * \param feature The requested feature |
| * \param version The version number of the feature |
| * \param object Pointer to location to receive object |
| * \return DOM_NO_ERR. |
| * |
| * Any memory allocated by this call should be allocated using |
| * the provided memory (de)allocation function. |
| */ |
| dom_exception dom_implementation_get_feature( |
| const char *feature, const char *version, |
| void **object) |
| { |
| UNUSED(feature); |
| UNUSED(version); |
| UNUSED(object); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/core/namednodemap.c |
|---|
| 0,0 → 1,329 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/core/element.h> |
| #include <dom/core/node.h> |
| #include <dom/core/string.h> |
| #include "core/document.h" |
| #include "core/element.h" |
| #include "core/namednodemap.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| /** |
| * DOM named node map |
| */ |
| struct dom_namednodemap { |
| dom_document *owner; /**< Owning document */ |
| void *priv; /**< Private data */ |
| struct nnm_operation *opt; /**< The underlaid operation |
| * implementations */ |
| uint32_t refcnt; /**< Reference count */ |
| }; |
| /** |
| * Create a namednodemap |
| * |
| * \param doc The owning document |
| * \param priv The private data of this dom_namednodemap |
| * \param opt The operation function pointer |
| * \param map Pointer to location to receive created map |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion |
| * |
| * ::head must be a node owned by ::doc and must be either an Element or |
| * DocumentType node. |
| * |
| * If ::head is of type Element, ::type must be DOM_ATTRIBUTE_NODE |
| * If ::head is of type DocumentType, ::type may be either |
| * DOM_ENTITY_NODE or DOM_NOTATION_NODE. |
| * |
| * The returned map will already be referenced, so the client need not |
| * explicitly reference it. The client must unref the map once it is |
| * finished with it. |
| */ |
| dom_exception _dom_namednodemap_create(dom_document *doc, |
| void *priv, struct nnm_operation *opt, |
| dom_namednodemap **map) |
| { |
| dom_namednodemap *m; |
| m = malloc(sizeof(dom_namednodemap)); |
| if (m == NULL) |
| return DOM_NO_MEM_ERR; |
| m->owner = doc; |
| m->priv = priv; |
| m->opt = opt; |
| m->refcnt = 1; |
| *map = m; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Claim a reference on a DOM named node map |
| * |
| * \param map The map to claim a reference on |
| */ |
| void dom_namednodemap_ref(dom_namednodemap *map) |
| { |
| assert(map != NULL); |
| map->refcnt++; |
| } |
| /** |
| * Release a reference on a DOM named node map |
| * |
| * \param map The map to release the reference from |
| * |
| * If the reference count reaches zero, any memory claimed by the |
| * map will be released |
| */ |
| void dom_namednodemap_unref(dom_namednodemap *map) |
| { |
| if (map == NULL) |
| return; |
| if (--map->refcnt == 0) { |
| /* Call the implementation specific destroy */ |
| map->opt->namednodemap_destroy(map->priv); |
| /* Destroy the map object */ |
| free(map); |
| } |
| } |
| /** |
| * Retrieve the length of a named node map |
| * |
| * \param map Map to retrieve length of |
| * \param length Pointer to location to receive length |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception dom_namednodemap_get_length(dom_namednodemap *map, |
| uint32_t *length) |
| { |
| assert(map->opt != NULL); |
| return map->opt->namednodemap_get_length(map->priv, length); |
| } |
| /** |
| * Retrieve an item by name from a named node map |
| * |
| * \param map The map to retrieve the item from |
| * \param name The name of the item to retrieve |
| * \param node Pointer to location to receive item |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have had its reference count increased. The client |
| * should unref the node once it has finished with it. |
| */ |
| dom_exception _dom_namednodemap_get_named_item(dom_namednodemap *map, |
| dom_string *name, dom_node **node) |
| { |
| assert(map->opt != NULL); |
| return map->opt->namednodemap_get_named_item(map->priv, name, node); |
| } |
| /** |
| * Add a node to a named node map, replacing any matching existing node |
| * |
| * \param map The map to add to |
| * \param arg The node to add |
| * \param node Pointer to location to receive replaced node |
| * \return DOM_NO_ERR on success, |
| * DOM_WRONG_DOCUMENT_ERR if ::arg was created from a |
| * different document than ::map, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::map is readonly, |
| * DOM_INUSE_ATTRIBUTE_ERR if ::arg is an Attr that is |
| * already an attribute on another |
| * Element, |
| * DOM_HIERARCHY_REQUEST_ERR if the type of ::arg is not |
| * permitted as a member of ::map. |
| * |
| * ::arg's nodeName attribute will be used to store it in ::map. It will |
| * be accessible using the nodeName attribute as the key for lookup. |
| * |
| * Replacing a node by itself has no effect. |
| * |
| * The returned node will have had its reference count increased. The client |
| * should unref the node once it has finished with it. |
| */ |
| dom_exception _dom_namednodemap_set_named_item(dom_namednodemap *map, |
| dom_node *arg, dom_node **node) |
| { |
| assert(map->opt != NULL); |
| return map->opt->namednodemap_set_named_item(map->priv, arg, node); |
| } |
| /** |
| * Remove an item by name from a named node map |
| * |
| * \param map The map to remove from |
| * \param name The name of the item to remove |
| * \param node Pointer to location to receive removed item |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_FOUND_ERR if there is no node named ::name |
| * in ::map, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::map is readonly. |
| * |
| * The returned node will have had its reference count increased. The client |
| * should unref the node once it has finished with it. |
| */ |
| dom_exception _dom_namednodemap_remove_named_item( |
| dom_namednodemap *map, dom_string *name, |
| dom_node **node) |
| { |
| assert(map->opt != NULL); |
| return map->opt->namednodemap_remove_named_item(map->priv, name, node); |
| } |
| /** |
| * Retrieve an item from a named node map |
| * |
| * \param map The map to retrieve the item from |
| * \param index The map index to retrieve |
| * \param node Pointer to location to receive item |
| * \return DOM_NO_ERR. |
| * |
| * ::index is a zero-based index into ::map. |
| * ::index lies in the range [0, length-1] |
| * |
| * The returned node will have had its reference count increased. The client |
| * should unref the node once it has finished with it. |
| */ |
| dom_exception _dom_namednodemap_item(dom_namednodemap *map, |
| uint32_t index, dom_node **node) |
| { |
| assert(map->opt != NULL); |
| return map->opt->namednodemap_item(map->priv, index, node); |
| } |
| /** |
| * Retrieve an item by namespace/localname from a named node map |
| * |
| * \param map The map to retrieve the item from |
| * \param namespace The namespace URI of the item to retrieve |
| * \param localname The local name of the node to retrieve |
| * \param node Pointer to location to receive item |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not support the |
| * feature "XML" and the language exposed |
| * through the Document does not support |
| * Namespaces. |
| * |
| * The returned node will have had its reference count increased. The client |
| * should unref the node once it has finished with it. |
| */ |
| dom_exception _dom_namednodemap_get_named_item_ns( |
| dom_namednodemap *map, dom_string *namespace, |
| dom_string *localname, dom_node **node) |
| { |
| assert(map->opt != NULL); |
| return map->opt->namednodemap_get_named_item_ns(map->priv, namespace, |
| localname, node); |
| } |
| /** |
| * Add a node to a named node map, replacing any matching existing node |
| * |
| * \param map The map to add to |
| * \param arg The node to add |
| * \param node Pointer to location to receive replaced node |
| * \return DOM_NO_ERR on success, |
| * DOM_WRONG_DOCUMENT_ERR if ::arg was created from a |
| * different document than ::map, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::map is readonly, |
| * DOM_INUSE_ATTRIBUTE_ERR if ::arg is an Attr that is |
| * already an attribute on another |
| * Element, |
| * DOM_HIERARCHY_REQUEST_ERR if the type of ::arg is not |
| * permitted as a member of ::map. |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not support the |
| * feature "XML" and the language exposed |
| * through the Document does not support |
| * Namespaces. |
| * |
| * ::arg's namespaceURI and localName attributes will be used to store it in |
| * ::map. It will be accessible using the namespaceURI and localName |
| * attributes as the keys for lookup. |
| * |
| * Replacing a node by itself has no effect. |
| * |
| * The returned node will have had its reference count increased. The client |
| * should unref the node once it has finished with it. |
| */ |
| dom_exception _dom_namednodemap_set_named_item_ns( |
| dom_namednodemap *map, dom_node *arg, |
| dom_node **node) |
| { |
| assert(map->opt != NULL); |
| return map->opt->namednodemap_set_named_item_ns(map->priv, arg, node); |
| } |
| /** |
| * Remove an item by namespace/localname from a named node map |
| * |
| * \param map The map to remove from |
| * \param namespace The namespace URI of the item to remove |
| * \param localname The local name of the item to remove |
| * \param node Pointer to location to receive removed item |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_FOUND_ERR if there is no node named ::name |
| * in ::map, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::map is readonly. |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not support the |
| * feature "XML" and the language exposed |
| * through the Document does not support |
| * Namespaces. |
| * |
| * The returned node will have had its reference count increased. The client |
| * should unref the node once it has finished with it. |
| */ |
| dom_exception _dom_namednodemap_remove_named_item_ns( |
| dom_namednodemap *map, dom_string *namespace, |
| dom_string *localname, dom_node **node) |
| { |
| assert(map->opt != NULL); |
| return map->opt->namednodemap_remove_named_item_ns(map->priv, namespace, |
| localname, node); |
| } |
| /** |
| * Compare whether two NamedNodeMap are equal. |
| * |
| */ |
| bool _dom_namednodemap_equal(dom_namednodemap *m1, |
| dom_namednodemap *m2) |
| { |
| assert(m1->opt != NULL); |
| return (m1->opt == m2->opt && m1->opt->namednodemap_equal(m1->priv, |
| m2->priv)); |
| } |
| /** |
| * Update the dom_namednodemap to make it as a proxy of another object |
| * |
| * \param map The dom_namednodemap |
| * \param priv The private data to change to |
| */ |
| void _dom_namednodemap_update(dom_namednodemap *map, void *priv) |
| { |
| map->priv = priv; |
| } |
| /contrib/network/netsurf/libdom/src/core/namednodemap.h |
|---|
| 0,0 → 1,70 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_namednodemap_h_ |
| #define dom_internal_core_namednodemap_h_ |
| #include <stdbool.h> |
| #include <dom/core/namednodemap.h> |
| #include <dom/core/node.h> |
| struct dom_document; |
| struct dom_node; |
| struct dom_namednodemap; |
| struct nnm_operation { |
| dom_exception (*namednodemap_get_length)(void *priv, |
| uint32_t *length); |
| dom_exception (*namednodemap_get_named_item)(void *priv, |
| dom_string *name, struct dom_node **node); |
| dom_exception (*namednodemap_set_named_item)(void *priv, |
| struct dom_node *arg, struct dom_node **node); |
| dom_exception (*namednodemap_remove_named_item)( |
| void *priv, dom_string *name, |
| struct dom_node **node); |
| dom_exception (*namednodemap_item)(void *priv, |
| uint32_t index, struct dom_node **node); |
| dom_exception (*namednodemap_get_named_item_ns)( |
| void *priv, dom_string *namespace, |
| dom_string *localname, struct dom_node **node); |
| dom_exception (*namednodemap_set_named_item_ns)( |
| void *priv, struct dom_node *arg, |
| struct dom_node **node); |
| dom_exception (*namednodemap_remove_named_item_ns)( |
| void *priv, dom_string *namespace, |
| dom_string *localname, struct dom_node **node); |
| void (*namednodemap_destroy)(void *priv); |
| bool (*namednodemap_equal)(void *p1, void *p2); |
| }; |
| /* Create a namednodemap */ |
| dom_exception _dom_namednodemap_create(struct dom_document *doc, |
| void *priv, struct nnm_operation *opt, |
| struct dom_namednodemap **map); |
| /* Update the private data */ |
| void _dom_namednodemap_update(struct dom_namednodemap *map, void *priv); |
| /* Test whether two maps are equal */ |
| bool _dom_namednodemap_equal(struct dom_namednodemap *m1, |
| struct dom_namednodemap *m2); |
| #define dom_namednodemap_equal(m1, m2) _dom_namednodemap_equal( \ |
| (struct dom_namednodemap *) (m1), \ |
| (struct dom_namednodemap *) (m2)) |
| #endif |
| /contrib/network/netsurf/libdom/src/core/node.c |
|---|
| 0,0 → 1,2513 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdbool.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <dom/core/attr.h> |
| #include <dom/core/text.h> |
| #include <dom/core/document.h> |
| #include <dom/core/namednodemap.h> |
| #include <dom/core/nodelist.h> |
| #include <dom/core/implementation.h> |
| #include <dom/core/document_type.h> |
| #include <dom/events/events.h> |
| #include "core/string.h" |
| #include "core/namednodemap.h" |
| #include "core/attr.h" |
| #include "core/cdatasection.h" |
| #include "core/comment.h" |
| #include "core/document.h" |
| #include "core/document_type.h" |
| #include "core/doc_fragment.h" |
| #include "core/element.h" |
| #include "core/entity_ref.h" |
| #include "core/node.h" |
| #include "core/pi.h" |
| #include "core/text.h" |
| #include "utils/utils.h" |
| #include "utils/validate.h" |
| #include "events/mutation_event.h" |
| static bool _dom_node_permitted_child(const dom_node_internal *parent, |
| const dom_node_internal *child); |
| static inline dom_exception _dom_node_attach(dom_node_internal *node, |
| dom_node_internal *parent, |
| dom_node_internal *previous, |
| dom_node_internal *next); |
| static inline void _dom_node_detach(dom_node_internal *node); |
| static inline dom_exception _dom_node_attach_range(dom_node_internal *first, |
| dom_node_internal *last, |
| dom_node_internal *parent, |
| dom_node_internal *previous, |
| dom_node_internal *next); |
| static inline void _dom_node_detach_range(dom_node_internal *first, |
| dom_node_internal *last); |
| static inline void _dom_node_replace(dom_node_internal *old, |
| dom_node_internal *replacement); |
| static struct dom_node_vtable node_vtable = { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE |
| }, |
| DOM_NODE_VTABLE |
| }; |
| static struct dom_node_protect_vtable node_protect_vtable = { |
| DOM_NODE_PROTECT_VTABLE |
| }; |
| /*----------------------------------------------------------------------*/ |
| /* The constructor and destructor of this object */ |
| /* Create a DOM node and compose the vtable */ |
| dom_node_internal * _dom_node_create(void) |
| { |
| dom_node_internal *node = malloc(sizeof(struct dom_node_internal)); |
| if (node == NULL) |
| return NULL; |
| node->base.vtable = &node_vtable; |
| node->vtable = &node_protect_vtable; |
| return node; |
| } |
| /** |
| * Destroy a DOM node |
| * |
| * \param node The node to destroy |
| * |
| * ::node's parent link must be NULL and its reference count must be 0. |
| * |
| * ::node will be freed. |
| * |
| * This function should only be called from dom_node_unref or type-specific |
| * destructors (for destroying child nodes). Anything else should not |
| * be attempting to destroy nodes -- they should simply be unreferencing |
| * them (so destruction will occur at the appropriate time). |
| */ |
| void _dom_node_destroy(struct dom_node_internal *node) |
| { |
| struct dom_document *owner = node->owner; |
| bool null_owner_permitted = (node->type == DOM_DOCUMENT_NODE || |
| node->type == DOM_DOCUMENT_TYPE_NODE); |
| assert(null_owner_permitted || owner != NULL); |
| if (!null_owner_permitted) { |
| /* Claim a reference upon the owning document during |
| * destruction to ensure that the document doesn't get |
| * destroyed before its contents. */ |
| dom_node_ref(owner); |
| } |
| /* Finalise this node, this should also destroy all the child nodes. */ |
| _dom_node_finalise(node); |
| if (!null_owner_permitted) { |
| /* Release the reference we claimed on the document. If this |
| * is the last reference held on the document and the list |
| * of nodes pending deletion is empty, then the document will |
| * be destroyed. */ |
| dom_node_unref(owner); |
| } |
| /* Release our memory */ |
| free(node); |
| } |
| /** |
| * Initialise a DOM node |
| * |
| * \param node The node to initialise |
| * \param doc The document which owns the node |
| * \param type The node type required |
| * \param name The node (local) name, or NULL |
| * \param value The node value, or NULL |
| * \param namespace Namespace URI to use for node, or NULL |
| * \param prefix Namespace prefix to use for node, or NULL |
| * \return DOM_NO_ERR on success. |
| * |
| * ::name, ::value, ::namespace, and ::prefix will have their reference |
| * counts increased. |
| */ |
| dom_exception _dom_node_initialise(dom_node_internal *node, |
| struct dom_document *doc, dom_node_type type, |
| dom_string *name, dom_string *value, |
| dom_string *namespace, dom_string *prefix) |
| { |
| node->owner = doc; |
| if (name != NULL) |
| node->name = dom_string_ref(name); |
| else |
| node->name = NULL; |
| if (value != NULL) |
| node->value = dom_string_ref(value); |
| else |
| node->value = NULL; |
| node->type = type; |
| node->parent = NULL; |
| node->first_child = NULL; |
| node->last_child = NULL; |
| node->previous = NULL; |
| node->next = NULL; |
| /* Note: nodes do not reference the document to which they belong, |
| * as this would result in the document never being destroyed once |
| * the client has finished with it. The document will be aware of |
| * any nodes that it owns through 2 mechanisms: |
| * |
| * either a) Membership of the document tree |
| * or b) Membership of the list of nodes pending deletion |
| * |
| * It is not possible for any given node to be a member of both |
| * data structures at the same time. |
| * |
| * The document will not be destroyed until both of these |
| * structures are empty. It will forcibly attempt to empty |
| * the document tree on document destruction. Any still-referenced |
| * nodes at that time will be added to the list of nodes pending |
| * deletion. This list will not be forcibly emptied, as it contains |
| * those nodes (and their sub-trees) in use by client code. |
| */ |
| if (namespace != NULL) |
| node->namespace = dom_string_ref(namespace); |
| else |
| node->namespace = NULL; |
| if (prefix != NULL) |
| node->prefix = dom_string_ref(prefix); |
| else |
| node->prefix = NULL; |
| node->user_data = NULL; |
| node->base.refcnt = 1; |
| list_init(&node->pending_list); |
| if (node->type != DOM_DOCUMENT_NODE) { |
| /* A Node should be in the pending list when it is created */ |
| dom_node_mark_pending(node); |
| } |
| return _dom_event_target_internal_initialise(&node->eti); |
| } |
| /** |
| * Finalise a DOM node |
| * |
| * \param node The node to finalise |
| * |
| * The contents of ::node will be cleaned up. ::node will not be freed. |
| * All children of ::node should have been removed prior to finalisation. |
| */ |
| void _dom_node_finalise(dom_node_internal *node) |
| { |
| struct dom_user_data *u, *v; |
| struct dom_node_internal *p; |
| struct dom_node_internal *n = NULL; |
| /* Destroy user data */ |
| for (u = node->user_data; u != NULL; u = v) { |
| v = u->next; |
| if (u->handler != NULL) |
| u->handler(DOM_NODE_DELETED, u->key, u->data, |
| NULL, NULL); |
| dom_string_unref(u->key); |
| free(u); |
| } |
| node->user_data = NULL; |
| if (node->prefix != NULL) { |
| dom_string_unref(node->prefix); |
| node->prefix = NULL; |
| } |
| if (node->namespace != NULL) { |
| dom_string_unref(node->namespace); |
| node->namespace = NULL; |
| } |
| /* Destroy all the child nodes of this node */ |
| p = node->first_child; |
| while (p != NULL) { |
| n = p->next; |
| p->parent = NULL; |
| dom_node_try_destroy(p); |
| p = n; |
| } |
| /* Paranoia */ |
| node->next = NULL; |
| node->previous = NULL; |
| node->last_child = NULL; |
| node->first_child = NULL; |
| node->parent = NULL; |
| if (node->value != NULL) { |
| dom_string_unref(node->value); |
| node->value = NULL; |
| } |
| if (node->name != NULL) { |
| dom_string_unref(node->name); |
| node->name = NULL; |
| } |
| /* If the node has no owner document, we need not to finalise its |
| * dom_event_target_internal structure. |
| */ |
| if (node->owner != NULL) |
| _dom_event_target_internal_finalise(&node->eti); |
| /* Detach from the pending list, if we are in it, |
| * this part of code should always be the end of this function. */ |
| if (node->pending_list.prev != &node->pending_list) { |
| assert (node->pending_list.next != &node->pending_list); |
| list_del(&node->pending_list); |
| if (node->owner != NULL && node->type != DOM_DOCUMENT_NODE) { |
| /* Deleting this node from the pending list may cause |
| * the list to be null and we should try to destroy |
| * the document. */ |
| _dom_document_try_destroy(node->owner); |
| } |
| } |
| } |
| /* ---------------------------------------------------------------------*/ |
| /* The public virtual function of this interface Node */ |
| /** |
| * Retrieve the name of a DOM node |
| * |
| * \param node The node to retrieve the name of |
| * \param result Pointer to location to receive node name |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_get_node_name(dom_node_internal *node, |
| dom_string **result) |
| { |
| dom_string *node_name, *temp; |
| dom_exception err; |
| /* Document Node and DocumentType Node can have no owner */ |
| assert(node->type == DOM_DOCUMENT_TYPE_NODE || |
| node->type == DOM_DOCUMENT_NODE || |
| node->owner != NULL); |
| assert(node->name != NULL); |
| /* If this node was created using a namespace-aware method and |
| * has a defined prefix, then nodeName is a QName comprised |
| * of prefix:name. */ |
| if (node->prefix != NULL) { |
| dom_string *colon; |
| err = dom_string_create((const uint8_t *) ":", SLEN(":"), |
| &colon); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Prefix + : */ |
| err = dom_string_concat(node->prefix, colon, &temp); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(colon); |
| return err; |
| } |
| /* Finished with colon */ |
| dom_string_unref(colon); |
| /* Prefix + : + Localname */ |
| err = dom_string_concat(temp, node->name, &node_name); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(temp); |
| return err; |
| } |
| /* Finished with temp */ |
| dom_string_unref(temp); |
| } else { |
| node_name = dom_string_ref(node->name); |
| } |
| *result = node_name; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the value of a DOM node |
| * |
| * \param node The node to retrieve the value of |
| * \param result Pointer to location to receive node value |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| * |
| * DOM3Core states that this can raise DOMSTRING_SIZE_ERR. It will not in |
| * this implementation; dom_strings are unbounded. |
| */ |
| dom_exception _dom_node_get_node_value(dom_node_internal *node, |
| dom_string **result) |
| { |
| if (node->value != NULL) |
| dom_string_ref(node->value); |
| *result = node->value; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the value of a DOM node |
| * |
| * \param node Node to set the value of |
| * \param value New value for node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if the node is readonly and the |
| * value is not defined to be null. |
| * |
| * The new value will have its reference count increased, so the caller |
| * should unref it after the call (as the caller should have already claimed |
| * a reference on the string). The node's existing value will be unrefed. |
| */ |
| dom_exception _dom_node_set_node_value(dom_node_internal *node, |
| dom_string *value) |
| { |
| /* TODO |
| * Whether we should change this to a virtual function? |
| */ |
| /* This is a NOP if the value is defined to be null. */ |
| if (node->type == DOM_DOCUMENT_NODE || |
| node->type == DOM_DOCUMENT_FRAGMENT_NODE || |
| node->type == DOM_DOCUMENT_TYPE_NODE || |
| node->type == DOM_ELEMENT_NODE || |
| node->type == DOM_ENTITY_NODE || |
| node->type == DOM_ENTITY_REFERENCE_NODE || |
| node->type == DOM_NOTATION_NODE) { |
| return DOM_NO_ERR; |
| } |
| /* Ensure node is writable */ |
| if (_dom_node_readonly(node)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| /* If it's an attribute node, then delegate setting to |
| * the type-specific function */ |
| if (node->type == DOM_ATTRIBUTE_NODE) |
| return dom_attr_set_value((struct dom_attr *) node, value); |
| if (node->value != NULL) |
| dom_string_unref(node->value); |
| if (value != NULL) |
| dom_string_ref(value); |
| node->value = value; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the type of a DOM node |
| * |
| * \param node The node to retrieve the type of |
| * \param result Pointer to location to receive node type |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_node_get_node_type(dom_node_internal *node, |
| dom_node_type *result) |
| { |
| *result = node->type; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the parent of a DOM node |
| * |
| * \param node The node to retrieve the parent of |
| * \param result Pointer to location to receive node parent |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_get_parent_node(dom_node_internal *node, |
| dom_node_internal **result) |
| { |
| /* Attr nodes have no parent */ |
| if (node->type == DOM_ATTRIBUTE_NODE) { |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /* If there is a parent node, then increase its reference count */ |
| if (node->parent != NULL) |
| dom_node_ref(node->parent); |
| *result = node->parent; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve a list of children of a DOM node |
| * |
| * \param node The node to retrieve the children of |
| * \param result Pointer to location to receive child list |
| * \return DOM_NO_ERR. |
| * |
| * The returned NodeList will be referenced. It is the responsibility |
| * of the caller to unref the list once it has finished with it. |
| */ |
| dom_exception _dom_node_get_child_nodes(dom_node_internal *node, |
| struct dom_nodelist **result) |
| { |
| /* Can't do anything without an owning document. |
| * This is only a problem for DocumentType nodes |
| * which are not yet attached to a document. |
| * DocumentType nodes have no children, anyway. */ |
| if (node->owner == NULL) |
| return DOM_NOT_SUPPORTED_ERR; |
| return _dom_document_get_nodelist(node->owner, DOM_NODELIST_CHILDREN, |
| node, NULL, NULL, NULL, result); |
| } |
| /** |
| * Retrieve the first child of a DOM node |
| * |
| * \param node The node to retrieve the first child of |
| * \param result Pointer to location to receive node's first child |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_get_first_child(dom_node_internal *node, |
| dom_node_internal **result) |
| { |
| /* If there is a first child, increase its reference count */ |
| if (node->first_child != NULL) |
| dom_node_ref(node->first_child); |
| *result = node->first_child; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the last child of a DOM node |
| * |
| * \param node The node to retrieve the last child of |
| * \param result Pointer to location to receive node's last child |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_get_last_child(dom_node_internal *node, |
| dom_node_internal **result) |
| { |
| /* If there is a last child, increase its reference count */ |
| if (node->last_child != NULL) |
| dom_node_ref(node->last_child); |
| *result = node->last_child; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the previous sibling of a DOM node |
| * |
| * \param node The node to retrieve the previous sibling of |
| * \param result Pointer to location to receive node's previous sibling |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_get_previous_sibling(dom_node_internal *node, |
| dom_node_internal **result) |
| { |
| /* Attr nodes have no previous siblings */ |
| if (node->type == DOM_ATTRIBUTE_NODE) { |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /* If there is a previous sibling, increase its reference count */ |
| if (node->previous != NULL) |
| dom_node_ref(node->previous); |
| *result = node->previous; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the subsequent sibling of a DOM node |
| * |
| * \param node The node to retrieve the subsequent sibling of |
| * \param result Pointer to location to receive node's subsequent sibling |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_get_next_sibling(dom_node_internal *node, |
| dom_node_internal **result) |
| { |
| /* Attr nodes have no next siblings */ |
| if (node->type == DOM_ATTRIBUTE_NODE) { |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /* If there is a subsequent sibling, increase its reference count */ |
| if (node->next != NULL) |
| dom_node_ref(node->next); |
| *result = node->next; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve a map of attributes associated with a DOM node |
| * |
| * \param node The node to retrieve the attributes of |
| * \param result Pointer to location to receive attribute map |
| * \return DOM_NO_ERR. |
| * |
| * The returned NamedNodeMap will be referenced. It is the responsibility |
| * of the caller to unref the map once it has finished with it. |
| * |
| * If ::node is not an Element, then NULL will be returned. |
| */ |
| dom_exception _dom_node_get_attributes(dom_node_internal *node, |
| struct dom_namednodemap **result) |
| { |
| UNUSED(node); |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the owning document of a DOM node |
| * |
| * \param node The node to retrieve the owner of |
| * \param result Pointer to location to receive node's owner |
| * \return DOM_NO_ERR. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_get_owner_document(dom_node_internal *node, |
| struct dom_document **result) |
| { |
| /* Document nodes have no owner, as far as clients are concerned |
| * In reality, they own themselves as this simplifies code elsewhere */ |
| if (node->type == DOM_DOCUMENT_NODE) { |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /* If there is an owner, increase its reference count */ |
| if (node->owner != NULL) |
| dom_node_ref(node->owner); |
| *result = node->owner; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Insert a child into a node |
| * |
| * \param node Node to insert into |
| * \param new_child Node to insert |
| * \param ref_child Node to insert before, or NULL to insert as last child |
| * \param result Pointer to location to receive node being inserted |
| * \return DOM_NO_ERR on success, |
| * DOM_HIERARCHY_REQUEST_ERR if ::new_child's type is not |
| * permitted as a child of ::node, |
| * or ::new_child is an ancestor of |
| * ::node (or is ::node itself), or |
| * ::node is of type Document and a |
| * second DocumentType or Element is |
| * being inserted, |
| * DOM_WRONG_DOCUMENT_ERR if ::new_child was created from a |
| * different document than ::node, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::node is readonly, or |
| * ::new_child's parent is readonly, |
| * DOM_NOT_FOUND_ERR if ::ref_child is not a child of |
| * ::node. |
| * |
| * If ::new_child is a DocumentFragment, all of its children are inserted. |
| * If ::new_child is already in the tree, it is first removed. |
| * |
| * Attempting to insert a node before itself is a NOP. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_insert_before(dom_node_internal *node, |
| dom_node_internal *new_child, dom_node_internal *ref_child, |
| dom_node_internal **result) |
| { |
| dom_exception err; |
| dom_node_internal *n; |
| assert(node != NULL); |
| /* Ensure that new_child and node are owned by the same document */ |
| if ((new_child->type == DOM_DOCUMENT_TYPE_NODE && |
| new_child->owner != NULL && |
| new_child->owner != node->owner) || |
| (new_child->type != DOM_DOCUMENT_TYPE_NODE && |
| new_child->owner != node->owner)) |
| return DOM_WRONG_DOCUMENT_ERR; |
| /* Ensure node isn't read only */ |
| if (_dom_node_readonly(node)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| /* Ensure that ref_child (if any) is a child of node */ |
| if (ref_child != NULL && ref_child->parent != node) |
| return DOM_NOT_FOUND_ERR; |
| /* Ensure that new_child is not an ancestor of node, nor node itself */ |
| for (n = node; n != NULL; n = n->parent) { |
| if (n == new_child) |
| return DOM_HIERARCHY_REQUEST_ERR; |
| } |
| /* Ensure that new_child is permitted as a child of node */ |
| if (new_child->type != DOM_DOCUMENT_FRAGMENT_NODE && |
| !_dom_node_permitted_child(node, new_child)) |
| return DOM_HIERARCHY_REQUEST_ERR; |
| /* Attempting to insert a node before itself is a NOP */ |
| if (new_child == ref_child) { |
| dom_node_ref(new_child); |
| *result = new_child; |
| return DOM_NO_ERR; |
| } |
| /* If new_child is already in the tree and |
| * its parent isn't read only, remove it */ |
| if (new_child->parent != NULL) { |
| if (_dom_node_readonly(new_child->parent)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| _dom_node_detach(new_child); |
| } |
| /* When a Node is attached, it should be removed from the pending |
| * list */ |
| dom_node_remove_pending(new_child); |
| /* If new_child is a DocumentFragment, insert its children. |
| * Otherwise, insert new_child */ |
| if (new_child->type == DOM_DOCUMENT_FRAGMENT_NODE) { |
| /* Test the children of the docment fragment can be appended */ |
| dom_node_internal *c = new_child->first_child; |
| for (; c != NULL; c = c->next) |
| if (!_dom_node_permitted_child(node, c)) |
| return DOM_HIERARCHY_REQUEST_ERR; |
| if (new_child->first_child != NULL) { |
| err = _dom_node_attach_range(new_child->first_child, |
| new_child->last_child, |
| node, |
| ref_child == NULL ? node->last_child |
| : ref_child->previous, |
| ref_child == NULL ? NULL |
| : ref_child); |
| if (err != DOM_NO_ERR) |
| return err; |
| new_child->first_child = NULL; |
| new_child->last_child = NULL; |
| } |
| } else { |
| err = _dom_node_attach(new_child, |
| node, |
| ref_child == NULL ? node->last_child |
| : ref_child->previous, |
| ref_child == NULL ? NULL |
| : ref_child); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| /* DocumentType nodes are created outside the Document so, |
| * if we're trying to attach a DocumentType node, then we |
| * also need to set its owner. */ |
| if (node->type == DOM_DOCUMENT_NODE && |
| new_child->type == DOM_DOCUMENT_TYPE_NODE) { |
| /* See long comment in _dom_node_initialise as to why |
| * we don't ref the document here */ |
| new_child->owner = (struct dom_document *) node; |
| } |
| /** \todo Is it correct to return DocumentFragments? */ |
| dom_node_ref(new_child); |
| *result = new_child; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Replace a node's child with a new one |
| * |
| * \param node Node whose child to replace |
| * \param new_child Replacement node |
| * \param old_child Child to replace |
| * \param result Pointer to location to receive replaced node |
| * \return DOM_NO_ERR on success, |
| * DOM_HIERARCHY_REQUEST_ERR if ::new_child's type is not |
| * permitted as a child of ::node, |
| * or ::new_child is an ancestor of |
| * ::node (or is ::node itself), or |
| * ::node is of type Document and a |
| * second DocumentType or Element is |
| * being inserted, |
| * DOM_WRONG_DOCUMENT_ERR if ::new_child was created from a |
| * different document than ::node, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::node is readonly, or |
| * ::new_child's parent is readonly, |
| * DOM_NOT_FOUND_ERR if ::old_child is not a child of |
| * ::node, |
| * DOM_NOT_SUPPORTED_ERR if ::node is of type Document and |
| * ::new_child is of type |
| * DocumentType or Element. |
| * |
| * If ::new_child is a DocumentFragment, ::old_child is replaced by all of |
| * ::new_child's children. |
| * If ::new_child is already in the tree, it is first removed. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_replace_child(dom_node_internal *node, |
| dom_node_internal *new_child, dom_node_internal *old_child, |
| dom_node_internal **result) |
| { |
| dom_node_internal *n; |
| /* We don't support replacement of DocumentType or root Elements */ |
| if (node->type == DOM_DOCUMENT_NODE && |
| (new_child->type == DOM_DOCUMENT_TYPE_NODE || |
| new_child->type == DOM_ELEMENT_NODE)) |
| return DOM_NOT_SUPPORTED_ERR; |
| /* Ensure that new_child and node are owned by the same document */ |
| if (new_child->owner != node->owner) |
| return DOM_WRONG_DOCUMENT_ERR; |
| /* Ensure node isn't read only */ |
| if (_dom_node_readonly(node)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| /* Ensure that old_child is a child of node */ |
| if (old_child->parent != node) |
| return DOM_NOT_FOUND_ERR; |
| /* Ensure that new_child is not an ancestor of node, nor node itself */ |
| for (n = node; n != NULL; n = n->parent) { |
| if (n == new_child) |
| return DOM_HIERARCHY_REQUEST_ERR; |
| } |
| /* Ensure that new_child is permitted as a child of node */ |
| if (new_child->type == DOM_DOCUMENT_FRAGMENT_NODE) { |
| /* If this node is a doc fragment, we should test all its |
| * children nodes */ |
| dom_node_internal *c; |
| c = new_child->first_child; |
| while (c != NULL) { |
| if (!_dom_node_permitted_child(node, c)) |
| return DOM_HIERARCHY_REQUEST_ERR; |
| c = c->next; |
| } |
| } else { |
| if (!_dom_node_permitted_child(node, new_child)) |
| return DOM_HIERARCHY_REQUEST_ERR; |
| } |
| /* Attempting to replace a node with itself is a NOP */ |
| if (new_child == old_child) { |
| dom_node_ref(old_child); |
| *result = old_child; |
| return DOM_NO_ERR; |
| } |
| /* If new_child is already in the tree and |
| * its parent isn't read only, remove it */ |
| if (new_child->parent != NULL) { |
| if (_dom_node_readonly(new_child->parent)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| _dom_node_detach(new_child); |
| } |
| /* When a Node is attached, it should be removed from the pending |
| * list */ |
| dom_node_remove_pending(new_child); |
| /* Perform the replacement */ |
| _dom_node_replace(old_child, new_child); |
| /* Sort out the return value */ |
| dom_node_ref(old_child); |
| /* The replaced node should be marded pending */ |
| dom_node_mark_pending(old_child); |
| *result = old_child; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Remove a child from a node |
| * |
| * \param node Node whose child to replace |
| * \param old_child Child to remove |
| * \param result Pointer to location to receive removed node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::node is readonly |
| * DOM_NOT_FOUND_ERR if ::old_child is not a child of |
| * ::node, |
| * DOM_NOT_SUPPORTED_ERR if ::node is of type Document and |
| * ::new_child is of type |
| * DocumentType or Element. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_remove_child(dom_node_internal *node, |
| dom_node_internal *old_child, |
| dom_node_internal **result) |
| { |
| dom_exception err; |
| bool success = true; |
| /* We don't support removal of DocumentType or root Element nodes */ |
| if (node->type == DOM_DOCUMENT_NODE && |
| (old_child->type == DOM_DOCUMENT_TYPE_NODE || |
| old_child->type == DOM_ELEMENT_NODE)) |
| return DOM_NOT_SUPPORTED_ERR; |
| /* Ensure old_child is a child of node */ |
| if (old_child->parent != node) |
| return DOM_NOT_FOUND_ERR; |
| /* Ensure node is writable */ |
| if (_dom_node_readonly(node)) |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| /* Dispatch a DOMNodeRemoval event */ |
| err = dom_node_dispatch_node_change_event(node->owner, old_child, node, |
| DOM_MUTATION_REMOVAL, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* Detach the node */ |
| _dom_node_detach(old_child); |
| /* When a Node is removed, it should be destroy. When its refcnt is not |
| * zero, it will be added to the document's deletion pending list. |
| * When a Node is removed, its parent should be NULL, but its owner |
| * should remain to be the document. */ |
| dom_node_ref(old_child); |
| dom_node_try_destroy(old_child); |
| *result = old_child; |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(node->owner, node, |
| &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Append a child to the end of a node's child list |
| * |
| * \param node Node to insert into |
| * \param new_child Node to append |
| * \param result Pointer to location to receive node being inserted |
| * \return DOM_NO_ERR on success, |
| * DOM_HIERARCHY_REQUEST_ERR if ::new_child's type is not |
| * permitted as a child of ::node, |
| * or ::new_child is an ancestor of |
| * ::node (or is ::node itself), or |
| * ::node is of type Document and a |
| * second DocumentType or Element is |
| * being inserted, |
| * DOM_WRONG_DOCUMENT_ERR if ::new_child was created from a |
| * different document than ::node, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::node is readonly, or |
| * ::new_child's parent is readonly. |
| * |
| * If ::new_child is a DocumentFragment, all of its children are inserted. |
| * If ::new_child is already in the tree, it is first removed. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_append_child(dom_node_internal *node, |
| dom_node_internal *new_child, |
| dom_node_internal **result) |
| { |
| /* This is just a veneer over insert_before */ |
| return dom_node_insert_before(node, new_child, NULL, result); |
| } |
| /** |
| * Determine if a node has any children |
| * |
| * \param node Node to inspect |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_node_has_child_nodes(dom_node_internal *node, bool *result) |
| { |
| *result = node->first_child != NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Clone a DOM node |
| * |
| * \param node The node to clone |
| * \param deep True to deep-clone the node's sub-tree |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEMORY_ERR on memory exhaustion. |
| * |
| * The returned node will already be referenced. |
| * |
| * The duplicate node will have no parent and no user data. |
| * |
| * If ::node has registered user_data_handlers, then they will be called. |
| * |
| * Cloning an Element copies all attributes & their values (including those |
| * generated by the XML processor to represent defaulted attributes). It |
| * does not copy any child nodes unless it is a deep copy (this includes |
| * text contained within the Element, as the text is contained in a child |
| * Text node). |
| * |
| * Cloning an Attr directly, as opposed to cloning as part of an Element, |
| * returns a specified attribute. Cloning an Attr always clones its children, |
| * since they represent its value, no matter whether this is a deep clone or |
| * not. |
| * |
| * Cloning an EntityReference automatically constructs its subtree if a |
| * corresponding Entity is available, no matter whether this is a deep clone |
| * or not. |
| * |
| * Cloning any other type of node simply returns a copy. |
| * |
| * Note that cloning an immutable subtree results in a mutable copy, but |
| * the children of an EntityReference clone are readonly. In addition, clones |
| * of unspecified Attr nodes are specified. |
| * |
| * \todo work out what happens when cloning Document, DocumentType, Entity |
| * and Notation nodes. |
| * |
| * Note: we adopt a OO paradigm, this clone_node just provide a basic operation |
| * of clone. Special clones like Attr/EntitiReference stated above should |
| * provide their overload of this interface in their implementation file. |
| */ |
| dom_exception _dom_node_clone_node(dom_node_internal *node, bool deep, |
| dom_node_internal **result) |
| { |
| dom_node_internal *n, *child, *r; |
| dom_exception err; |
| dom_user_data *ud; |
| assert(node->owner != NULL); |
| err = dom_node_copy(node, &n); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| if (deep) { |
| child = node->first_child; |
| while (child != NULL) { |
| err = dom_node_clone_node(child, deep, (void *) &r); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(n); |
| return err; |
| } |
| err = dom_node_append_child(n, r, (void *) &r); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(n); |
| return err; |
| } |
| /* Clean up the new node, we have reference it two |
| * times */ |
| dom_node_unref(r); |
| dom_node_unref(r); |
| child = child->next; |
| } |
| } |
| *result = n; |
| /* Call the dom_user_data_handlers */ |
| ud = node->user_data; |
| while (ud != NULL) { |
| if (ud->handler != NULL) |
| ud->handler(DOM_NODE_CLONED, ud->key, ud->data, |
| (dom_node *) node, (dom_node *) n); |
| ud = ud->next; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Normalize a DOM node |
| * |
| * \param node The node to normalize |
| * \return DOM_NO_ERR. |
| * |
| * Puts all Text nodes in the full depth of the sub-tree beneath ::node, |
| * including Attr nodes into "normal" form, where only structure separates |
| * Text nodes. |
| */ |
| dom_exception _dom_node_normalize(dom_node_internal *node) |
| { |
| dom_node_internal *n, *p; |
| dom_exception err; |
| p = node->first_child; |
| if (p == NULL) |
| return DOM_NO_ERR; |
| n = p->next; |
| while (n != NULL) { |
| if (n->type == DOM_TEXT_NODE && p->type == DOM_TEXT_NODE) { |
| err = _dom_merge_adjacent_text(p, n); |
| if (err != DOM_NO_ERR) |
| return err; |
| _dom_node_detach(n); |
| dom_node_unref(n); |
| n = p->next; |
| continue; |
| } |
| if (n->type != DOM_TEXT_NODE) { |
| err = dom_node_normalize(n); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| p = n; |
| n = n->next; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Test whether the DOM implementation implements a specific feature and |
| * that feature is supported by the node. |
| * |
| * \param node The node to test |
| * \param feature The name of the feature to test |
| * \param version The version number of the feature to test |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_node_is_supported(dom_node_internal *node, |
| dom_string *feature, dom_string *version, |
| bool *result) |
| { |
| bool has; |
| UNUSED(node); |
| dom_implementation_has_feature(dom_string_data(feature), |
| dom_string_data(version), &has); |
| *result = has; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the namespace of a DOM node |
| * |
| * \param node The node to retrieve the namespace of |
| * \param result Pointer to location to receive node's namespace |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_get_namespace(dom_node_internal *node, |
| dom_string **result) |
| { |
| assert(node->owner != NULL); |
| /* If there is a namespace, increase its reference count */ |
| if (node->namespace != NULL) |
| *result = dom_string_ref(node->namespace); |
| else |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the prefix of a DOM node |
| * |
| * \param node The node to retrieve the prefix of |
| * \param result Pointer to location to receive node's prefix |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_get_prefix(dom_node_internal *node, |
| dom_string **result) |
| { |
| assert(node->owner != NULL); |
| /* If there is a prefix, increase its reference count */ |
| if (node->prefix != NULL) |
| *result = dom_string_ref(node->prefix); |
| else |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the prefix of a DOM node |
| * |
| * \param node The node to set the prefix of |
| * \param prefix Pointer to prefix string |
| * \return DOM_NO_ERR on success, |
| * DOM_INVALID_CHARACTER_ERR if the specified prefix contains |
| * an illegal character, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::node is readonly, |
| * DOM_NAMESPACE_ERR if the specified prefix is |
| * malformed, if the namespaceURI of |
| * ::node is null, if the specified |
| * prefix is "xml" and the |
| * namespaceURI is different from |
| * "http://www.w3.org/XML/1998/namespace", |
| * if ::node is an attribute and the |
| * specified prefix is "xmlns" and |
| * the namespaceURI is different from |
| * "http://www.w3.org/2000/xmlns", |
| * or if this node is an attribute |
| * and the qualifiedName of ::node |
| * is "xmlns". |
| */ |
| dom_exception _dom_node_set_prefix(dom_node_internal *node, |
| dom_string *prefix) |
| { |
| /* Only Element and Attribute nodes created using |
| * namespace-aware methods may have a prefix */ |
| if ((node->type != DOM_ELEMENT_NODE && |
| node->type != DOM_ATTRIBUTE_NODE) || |
| node->namespace == NULL) { |
| return DOM_NO_ERR; |
| } |
| /** \todo validate prefix */ |
| /* Ensure node is writable */ |
| if (_dom_node_readonly(node)) { |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| } |
| /* No longer want existing prefix */ |
| if (node->prefix != NULL) { |
| dom_string_unref(node->prefix); |
| } |
| /* Set the prefix */ |
| if (prefix != NULL) { |
| /* Empty string is treated as NULL */ |
| if (dom_string_length(prefix) == 0) { |
| node->prefix = NULL; |
| } else { |
| node->prefix = dom_string_ref(prefix); |
| } |
| } else { |
| node->prefix = NULL; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the local part of a node's qualified name |
| * |
| * \param node The node to retrieve the local name of |
| * \param result Pointer to location to receive local name |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_get_local_name(dom_node_internal *node, |
| dom_string **result) |
| { |
| assert(node->owner != NULL); |
| /* Only Element and Attribute nodes may have a local name */ |
| if (node->type != DOM_ELEMENT_NODE && |
| node->type != DOM_ATTRIBUTE_NODE) { |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /* The node may have a local name, reference it if so */ |
| if (node->name != NULL) |
| *result = dom_string_ref(node->name); |
| else |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Determine if a node has any attributes |
| * |
| * \param node Node to inspect |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_node_has_attributes(dom_node_internal *node, bool *result) |
| { |
| UNUSED(node); |
| *result = false; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve the base URI of a DOM node |
| * |
| * \param node The node to retrieve the base URI of |
| * \param result Pointer to location to receive base URI |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| * |
| * We don't support this API now, so this function call should always |
| * return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_node_get_base(dom_node_internal *node, |
| dom_string **result) |
| { |
| struct dom_document *doc = node->owner; |
| assert(doc != NULL); |
| return dom_document_get_base(doc, result); |
| } |
| /** |
| * Compare the positions of two nodes in a DOM tree |
| * |
| * \param node The reference node |
| * \param other The node to compare |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_SUPPORTED_ERR when the nodes are from different DOM |
| * implementations. |
| * |
| * The result is a bitfield of dom_document_position values. |
| * |
| * We don't support this API now, so this function call should always |
| * return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_node_compare_document_position(dom_node_internal *node, |
| dom_node_internal *other, uint16_t *result) |
| { |
| UNUSED(node); |
| UNUSED(other); |
| UNUSED(result); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Retrieve the text content of a DOM node |
| * |
| * \param node The node to retrieve the text content of |
| * \param result Pointer to location to receive text content |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| * |
| * If there is no text content in the code, NULL will returned in \a result. |
| * |
| * DOM3Core states that this can raise DOMSTRING_SIZE_ERR. It will not in |
| * this implementation; dom_strings are unbounded. |
| */ |
| dom_exception _dom_node_get_text_content(dom_node_internal *node, |
| dom_string **result) |
| { |
| dom_node_internal *n; |
| dom_string *str = NULL; |
| dom_string *ret = NULL; |
| assert(node->owner != NULL); |
| for (n = node->first_child; n != NULL; n = n->next) { |
| if (n->type == DOM_COMMENT_NODE || |
| n->type == DOM_PROCESSING_INSTRUCTION_NODE) |
| continue; |
| dom_node_get_text_content(n, (str == NULL) ? &str : &ret); |
| if (ret != NULL) { |
| dom_string *new_str; |
| dom_string_concat(str, ret, &new_str); |
| dom_string_unref(str); |
| dom_string_unref(ret); |
| str = new_str; |
| } |
| } |
| *result = str; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the text content of a DOM node |
| * |
| * \param node The node to set the text content of |
| * \param content New text content for node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::node is readonly. |
| * |
| * Any child nodes ::node may have are removed and replaced with a single |
| * Text node containing the new content. |
| */ |
| dom_exception _dom_node_set_text_content(dom_node_internal *node, |
| dom_string *content) |
| { |
| dom_node_internal *n, *p, *r; |
| dom_document *doc; |
| dom_text *text; |
| dom_exception err; |
| n = node->first_child; |
| while (n != NULL) { |
| p = n; |
| n = n->next; |
| /* Add the (void *) casting to avoid gcc warning: |
| * dereferencing type-punned pointer will break |
| * strict-aliasing rules */ |
| err = dom_node_remove_child(node, p, (void *) &r); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| doc = node->owner; |
| assert(doc != NULL); |
| err = dom_document_create_text_node(doc, content, &text); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_node_append_child(node, text, (void *) &r); |
| if (err != DOM_NO_ERR) |
| return err; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Determine if two DOM nodes are the same |
| * |
| * \param node The node to compare |
| * \param other The node to compare against |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * This tests if the two nodes reference the same object. |
| */ |
| dom_exception _dom_node_is_same(dom_node_internal *node, |
| dom_node_internal *other, bool *result) |
| { |
| *result = (node == other); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Lookup the prefix associated with the given namespace URI |
| * |
| * \param node The node to start prefix search from |
| * \param namespace The namespace URI |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_lookup_prefix(dom_node_internal *node, |
| dom_string *namespace, dom_string **result) |
| { |
| if (node->parent != NULL) |
| return dom_node_lookup_prefix(node, namespace, result); |
| else |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Determine if the specified namespace is the default namespace |
| * |
| * \param node The node to query |
| * \param namespace The namespace URI to test |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_node_is_default_namespace(dom_node_internal *node, |
| dom_string *namespace, bool *result) |
| { |
| if (node->parent != NULL) |
| return dom_node_is_default_namespace(node, namespace, result); |
| else |
| *result = false; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Lookup the namespace URI associated with the given prefix |
| * |
| * \param node The node to start namespace search from |
| * \param prefix The prefix to look for, or NULL to find default. |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned string will have its reference count increased. It is |
| * the responsibility of the caller to unref the string once it has |
| * finished with it. |
| */ |
| dom_exception _dom_node_lookup_namespace(dom_node_internal *node, |
| dom_string *prefix, dom_string **result) |
| { |
| if (node->parent != NULL) |
| return dom_node_lookup_namespace(node->parent, prefix, result); |
| else |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Determine if two DOM nodes are equal |
| * |
| * \param node The node to compare |
| * \param other The node to compare against |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * Two nodes are equal iff: |
| * + They are of the same type |
| * + nodeName, localName, namespaceURI, prefix, nodeValue are equal |
| * + The node attributes are equal |
| * + The child nodes are equal |
| * |
| * Two DocumentType nodes are equal iff: |
| * + publicId, systemId, internalSubset are equal |
| * + The node entities are equal |
| * + The node notations are equal |
| * TODO: in document_type, we should override this virtual function |
| */ |
| dom_exception _dom_node_is_equal(dom_node_internal *node, |
| dom_node_internal *other, bool *result) |
| { |
| dom_exception err; |
| dom_string *s1, *s2; |
| dom_namednodemap *m1, *m2; |
| dom_nodelist *l1, *l2; |
| if (node->type != other->type){ |
| *result = false; |
| return DOM_NO_ERR; |
| } |
| assert(node->owner != NULL); |
| assert(other->owner != NULL); |
| err = dom_node_get_node_name(node, &s1); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_node_get_node_name(other, &s2); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (dom_string_isequal(s1, s2) == false) { |
| *result = false; |
| return DOM_NO_ERR; |
| } |
| if (node->name != other->name || |
| node->namespace != other->namespace || |
| node->prefix != other->prefix) { |
| *result = false; |
| return DOM_NO_ERR; |
| } |
| if (dom_string_isequal(node->value, other->value) == false) { |
| *result = false; |
| return DOM_NO_ERR; |
| } |
| // Following comes the attributes |
| err = dom_node_get_attributes(node, &m1); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_node_get_attributes(other, &m2); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (dom_namednodemap_equal(m1, m2) != true) { |
| *result = false; |
| return DOM_NO_ERR; |
| } |
| // Finally the childNodes |
| err = dom_node_get_child_nodes(node, &l1); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_node_get_child_nodes(other, &l2); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (dom_nodelist_equal(l1, l2) != true) { |
| *result = false; |
| return DOM_NO_ERR; |
| } |
| *result = true; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve an object which implements the specialized APIs of the specified |
| * feature and version. |
| * |
| * \param node The node to query |
| * \param feature The requested feature |
| * \param version The version number of the feature |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_node_get_feature(dom_node_internal *node, |
| dom_string *feature, dom_string *version, |
| void **result) |
| { |
| bool has; |
| dom_implementation_has_feature(dom_string_data(feature), |
| dom_string_data(version), &has); |
| if (has) { |
| *result = node; |
| } else { |
| *result = NULL; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Associate an object to a key on this node |
| * |
| * \param node The node to insert object into |
| * \param key The key associated with the object |
| * \param data The object to associate with key, or NULL to remove |
| * \param handler User handler function, or NULL if none |
| * \param result Pointer to location to receive previously associated object |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_node_set_user_data(dom_node_internal *node, |
| dom_string *key, void *data, |
| dom_user_data_handler handler, void **result) |
| { |
| struct dom_user_data *ud = NULL; |
| void *prevdata = NULL; |
| /* Search for user data */ |
| for (ud = node->user_data; ud != NULL; ud = ud->next) { |
| if (dom_string_isequal(ud->key, key)) |
| break; |
| }; |
| /* Remove it, if found and no new data */ |
| if (data == NULL && ud != NULL) { |
| dom_string_unref(ud->key); |
| if (ud->next != NULL) |
| ud->next->prev = ud->prev; |
| if (ud->prev != NULL) |
| ud->prev->next = ud->next; |
| else |
| node->user_data = ud->next; |
| *result = ud->data; |
| free(ud); |
| return DOM_NO_ERR; |
| } |
| /* Otherwise, create a new user data object if one wasn't found */ |
| if (ud == NULL) { |
| ud = malloc(sizeof(struct dom_user_data)); |
| if (ud == NULL) |
| return DOM_NO_MEM_ERR; |
| dom_string_ref(key); |
| ud->key = key; |
| ud->data = NULL; |
| ud->handler = NULL; |
| /* Insert into list */ |
| ud->prev = NULL; |
| ud->next = node->user_data; |
| if (node->user_data) |
| node->user_data->prev = ud; |
| node->user_data = ud; |
| } |
| prevdata = ud->data; |
| /* And associate data with it */ |
| ud->data = data; |
| ud->handler = handler; |
| *result = prevdata; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieves the object associated to a key on this node |
| * |
| * \param node The node to retrieve object from |
| * \param key The key to search for |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_node_get_user_data(dom_node_internal *node, |
| dom_string *key, void **result) |
| { |
| struct dom_user_data *ud = NULL; |
| /* Search for user data */ |
| for (ud = node->user_data; ud != NULL; ud = ud->next) { |
| if (dom_string_isequal(ud->key, key)) |
| break; |
| }; |
| if (ud != NULL) |
| *result = ud->data; |
| else |
| *result = NULL; |
| return DOM_NO_ERR; |
| } |
| /*--------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* Copy the internal attributes of a Node from old to new */ |
| dom_exception _dom_node_copy(dom_node_internal *old, dom_node_internal **copy) |
| { |
| dom_node_internal *new_node; |
| dom_exception err; |
| new_node = malloc(sizeof(dom_node_internal)); |
| if (new_node == NULL) |
| return DOM_NO_MEM_ERR; |
| err = _dom_node_copy_internal(old, new_node); |
| if (err != DOM_NO_ERR) { |
| free(new_node); |
| return err; |
| } |
| *copy = new_node; |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_node_copy_internal(dom_node_internal *old, |
| dom_node_internal *new) |
| { |
| new->base.vtable = old->base.vtable; |
| new->vtable = old->vtable; |
| new->name = dom_string_ref(old->name); |
| /* Value - see below */ |
| new->type = old->type; |
| new->parent = NULL; |
| new->first_child = NULL; |
| new->last_child = NULL; |
| new->previous = NULL; |
| new->next = NULL; |
| assert(old->owner != NULL); |
| new->owner = old->owner; |
| if (old->namespace != NULL) |
| new->namespace = dom_string_ref(old->namespace); |
| else |
| new->namespace = NULL; |
| if (old->prefix != NULL) |
| new->prefix = dom_string_ref(old->prefix); |
| else |
| new->prefix = NULL; |
| new->user_data = NULL; |
| new->base.refcnt = 1; |
| list_init(&new->pending_list); |
| /* Value */ |
| if (old->value != NULL) { |
| dom_string_ref(old->value); |
| new->value = old->value; |
| } else { |
| new->value = NULL; |
| } |
| /* The new copyed node has no parent, |
| * so it should be put in the pending list. */ |
| dom_node_mark_pending(new); |
| /* Intialise the EventTarget interface */ |
| return _dom_event_target_internal_initialise(&new->eti); |
| } |
| /*--------------------------------------------------------------------------*/ |
| /* The helper functions */ |
| /** |
| * Determine if a node is permitted as a child of another node |
| * |
| * \param parent Prospective parent |
| * \param child Prospective child |
| * \return true if ::child is permitted as a child of ::parent, false otherwise. |
| */ |
| bool _dom_node_permitted_child(const dom_node_internal *parent, |
| const dom_node_internal *child) |
| { |
| bool valid = false; |
| /* See DOM3Core $1.1.1 for details */ |
| switch (parent->type) { |
| case DOM_ELEMENT_NODE: |
| case DOM_ENTITY_REFERENCE_NODE: |
| case DOM_ENTITY_NODE: |
| case DOM_DOCUMENT_FRAGMENT_NODE: |
| valid = (child->type == DOM_ELEMENT_NODE || |
| child->type == DOM_TEXT_NODE || |
| child->type == DOM_COMMENT_NODE || |
| child->type == DOM_PROCESSING_INSTRUCTION_NODE || |
| child->type == DOM_CDATA_SECTION_NODE || |
| child->type == DOM_ENTITY_REFERENCE_NODE); |
| break; |
| case DOM_ATTRIBUTE_NODE: |
| valid = (child->type == DOM_TEXT_NODE || |
| child->type == DOM_ENTITY_REFERENCE_NODE); |
| break; |
| case DOM_TEXT_NODE: |
| case DOM_CDATA_SECTION_NODE: |
| case DOM_PROCESSING_INSTRUCTION_NODE: |
| case DOM_COMMENT_NODE: |
| case DOM_DOCUMENT_TYPE_NODE: |
| case DOM_NOTATION_NODE: |
| valid = false; |
| break; |
| case DOM_DOCUMENT_NODE: |
| valid = (child->type == DOM_ELEMENT_NODE || |
| child->type == DOM_PROCESSING_INSTRUCTION_NODE || |
| child->type == DOM_COMMENT_NODE || |
| child->type == DOM_DOCUMENT_TYPE_NODE); |
| /* Ensure that the document doesn't already |
| * have a root element */ |
| if (child->type == DOM_ELEMENT_NODE) { |
| dom_node_internal *n; |
| for (n = parent->first_child; |
| n != NULL; n = n->next) { |
| if (n->type == DOM_ELEMENT_NODE) |
| valid = false; |
| } |
| } |
| /* Ensure that the document doesn't already |
| * have a document type */ |
| if (child->type == DOM_DOCUMENT_TYPE_NODE) { |
| dom_node_internal *n; |
| for (n = parent->first_child; |
| n != NULL; n = n->next) { |
| if (n->type == DOM_DOCUMENT_TYPE_NODE) |
| valid = false; |
| } |
| } |
| break; |
| } |
| return valid; |
| } |
| /** |
| * Determine if a node is read only |
| * |
| * \param node The node to consider |
| */ |
| bool _dom_node_readonly(const dom_node_internal *node) |
| { |
| const dom_node_internal *n = node; |
| /* DocumentType and Notation ns are read only */ |
| if (n->type == DOM_DOCUMENT_TYPE_NODE || |
| n->type == DOM_NOTATION_NODE) |
| return true; |
| /* Some Attr node are readonly */ |
| if (n->type == DOM_ATTRIBUTE_NODE) |
| return _dom_attr_readonly((const dom_attr *) n); |
| /* Entity ns and their descendants are read only |
| * EntityReference ns and their descendants are read only */ |
| for (n = node; n != NULL; n = n->parent) { |
| if (n->type == DOM_ENTITY_NODE |
| || n->type == DOM_ENTITY_REFERENCE_NODE) |
| return true; |
| } |
| /* Otherwise, it's writable */ |
| return false; |
| } |
| /** |
| * Attach a node to the tree |
| * |
| * \param node The node to attach |
| * \param parent Node to attach ::node as child of |
| * \param previous Previous node in sibling list, or NULL if none |
| * \param next Next node in sibling list, or NULL if none |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_node_attach(dom_node_internal *node, |
| dom_node_internal *parent, dom_node_internal *previous, |
| dom_node_internal *next) |
| { |
| return _dom_node_attach_range(node, node, parent, previous, next); |
| } |
| /** |
| * Detach a node from the tree |
| * |
| * \param node The node to detach |
| */ |
| void _dom_node_detach(dom_node_internal *node) |
| { |
| /* When a Node is not in the document tree, it must be in the |
| * pending list */ |
| dom_node_mark_pending(node); |
| _dom_node_detach_range(node, node); |
| } |
| /** |
| * Attach a range of nodes to the tree |
| * |
| * \param first First node in the range |
| * \param last Last node in the range |
| * \param parent Node to attach range to |
| * \param previous Previous node in sibling list, or NULL if none |
| * \param next Next node in sibling list, or NULL if none |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * The range is assumed to be a linked list of sibling nodes. |
| */ |
| dom_exception _dom_node_attach_range(dom_node_internal *first, |
| dom_node_internal *last, |
| dom_node_internal *parent, |
| dom_node_internal *previous, |
| dom_node_internal *next) |
| { |
| dom_exception err; |
| bool success = true; |
| dom_node_internal *n; |
| first->previous = previous; |
| last->next = next; |
| if (previous != NULL) |
| previous->next = first; |
| else |
| parent->first_child = first; |
| if (next != NULL) |
| next->previous = last; |
| else |
| parent->last_child = last; |
| for (n = first; n != last->next; n = n->next) { |
| n->parent = parent; |
| /* Dispatch a DOMNodeInserted event */ |
| err = dom_node_dispatch_node_change_event(parent->owner, |
| n, parent, DOM_MUTATION_ADDITION, &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| success = true; |
| err = _dom_dispatch_subtree_modified_event(parent->owner, parent, |
| &success); |
| if (err != DOM_NO_ERR) |
| return err; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Detach a range of nodes from the tree |
| * |
| * \param first The first node in the range |
| * \param last The last node in the range |
| * |
| * The range is assumed to be a linked list of sibling nodes. |
| */ |
| void _dom_node_detach_range(dom_node_internal *first, |
| dom_node_internal *last) |
| { |
| bool success = true; |
| dom_node_internal *parent; |
| dom_node_internal *n; |
| if (first->previous != NULL) |
| first->previous->next = last->next; |
| else |
| first->parent->first_child = last->next; |
| if (last->next != NULL) |
| last->next->previous = first->previous; |
| else |
| last->parent->last_child = first->previous; |
| parent = first->parent; |
| for (n = first; n != last->next; n = n->next) { |
| /* Dispatch a DOMNodeRemoval event */ |
| dom_node_dispatch_node_change_event(n->owner, n, n->parent, |
| DOM_MUTATION_REMOVAL, &success); |
| n->parent = NULL; |
| } |
| success = true; |
| _dom_dispatch_subtree_modified_event(parent->owner, parent, |
| &success); |
| first->previous = NULL; |
| last->next = NULL; |
| } |
| /** |
| * Replace a node in the tree |
| * |
| * \param old Node to replace |
| * \param replacement Replacement node |
| * |
| * This is not implemented in terms of attach/detach in case |
| * we want to perform any special replacement-related behaviour |
| * at a later date. |
| */ |
| void _dom_node_replace(dom_node_internal *old, |
| dom_node_internal *replacement) |
| { |
| dom_node_internal *first, *last; |
| dom_node_internal *n; |
| if (replacement->type == DOM_DOCUMENT_FRAGMENT_NODE) { |
| first = replacement->first_child; |
| last = replacement->last_child; |
| replacement->first_child = replacement->last_child = NULL; |
| } else { |
| first = replacement; |
| last = replacement; |
| } |
| first->previous = old->previous; |
| last->next = old->next; |
| if (old->previous != NULL) |
| old->previous->next = first; |
| else |
| old->parent->first_child = first; |
| if (old->next != NULL) |
| old->next->previous = last; |
| else |
| old->parent->last_child = last; |
| for (n = first; n != last->next; n = n->next) { |
| n->parent = old->parent; |
| } |
| old->previous = old->next = old->parent = NULL; |
| } |
| /** |
| * Merge two adjacent text nodes into one text node. |
| * |
| * \param p The first text node |
| * \param n The second text node |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_merge_adjacent_text(dom_node_internal *p, |
| dom_node_internal *n) |
| { |
| dom_string *str; |
| dom_exception err; |
| assert(p->type = DOM_TEXT_NODE); |
| assert(n->type = DOM_TEXT_NODE); |
| err = dom_text_get_whole_text(n, &str); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_characterdata_append_data(p, str); |
| if (err != DOM_NO_ERR) |
| return err; |
| dom_string_unref(str); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Try to destroy this node. |
| * |
| * \param node The node to destroy |
| * |
| * When some node owns this node, (such as an elment owns its attribute nodes) |
| * when this node being not owned, the owner should call this function to try |
| * to destroy this node. |
| * |
| * @note: Owning a node does not means this node's refcnt is above zero. |
| */ |
| dom_exception _dom_node_try_destroy(dom_node_internal *node) |
| { |
| if (node == NULL) |
| return DOM_NO_ERR; |
| if (node->parent == NULL) { |
| if (node->base.refcnt == 0) { |
| dom_node_destroy(node); |
| } else if (node->pending_list.prev == &node->pending_list){ |
| assert (node->pending_list.next == &node->pending_list); |
| list_append(&node->owner->pending_nodes, |
| &node->pending_list); |
| } |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * To add some node to the pending list, when a node is removed from its parent |
| * or an attribute is removed from its element |
| * |
| * \param node The Node instance |
| */ |
| void _dom_node_mark_pending(dom_node_internal *node) |
| { |
| struct dom_document *doc = node->owner; |
| /* TODO: the pending_list is located at in dom_document, but some |
| * nodes can be created without a document created, such as a |
| * dom_document_type node. For this reason, we should test whether |
| * the doc is NULL. */ |
| if (doc != NULL) { |
| /* The node must not be in the pending list */ |
| assert(node->pending_list.prev == &node->pending_list); |
| list_append(&doc->pending_nodes, &node->pending_list); |
| } |
| } |
| /** |
| * To remove the node from the pending list, this may happen when |
| * a node is removed and then appended to another parent |
| * |
| * \param node The Node instance |
| */ |
| void _dom_node_remove_pending(dom_node_internal *node) |
| { |
| struct dom_document *doc = node->owner; |
| if (doc != NULL) { |
| /* The node must be in the pending list */ |
| assert(node->pending_list.prev != &node->pending_list); |
| list_del(&node->pending_list); |
| } |
| } |
| /****************************************************************************** |
| * Event Target API * |
| ******************************************************************************/ |
| dom_exception _dom_node_add_event_listener(dom_event_target *et, |
| dom_string *type, struct dom_event_listener *listener, |
| bool capture) |
| { |
| dom_node_internal *node = (dom_node_internal *) et; |
| return _dom_event_target_add_event_listener(&node->eti, type, |
| listener, capture); |
| } |
| dom_exception _dom_node_remove_event_listener(dom_event_target *et, |
| dom_string *type, struct dom_event_listener *listener, |
| bool capture) |
| { |
| dom_node_internal *node = (dom_node_internal *) et; |
| return _dom_event_target_remove_event_listener(&node->eti, |
| type, listener, capture); |
| } |
| dom_exception _dom_node_add_event_listener_ns(dom_event_target *et, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, bool capture) |
| { |
| dom_node_internal *node = (dom_node_internal *) et; |
| return _dom_event_target_add_event_listener_ns(&node->eti, |
| namespace, type, listener, capture); |
| } |
| dom_exception _dom_node_remove_event_listener_ns(dom_event_target *et, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, bool capture) |
| { |
| dom_node_internal *node = (dom_node_internal *) et; |
| return _dom_event_target_remove_event_listener_ns(&node->eti, |
| namespace, type, listener, capture); |
| } |
| /** |
| * Dispatch an event into the implementation's event model |
| * |
| * \param et The EventTarget object |
| * \param eti Internal EventTarget |
| * \param evt The event object |
| * \param success Indicates whether any of the listeners which handled the |
| * event called Event.preventDefault(). If |
| * Event.preventDefault() was called the returned value is |
| * false, else it is true. |
| * \return DOM_NO_ERR on success |
| * DOM_DISPATCH_REQUEST_ERR If the event is already in dispatch |
| * DOM_UNSPECIFIED_EVENT_TYPE_ERR If the type of the event is Null or |
| * empty string. |
| * DOM_NOT_SUPPORTED_ERR If the event is not created by |
| * Document.createEvent |
| * DOM_INVALID_CHARACTER_ERR If the type of this event is not a |
| * valid NCName. |
| */ |
| dom_exception _dom_node_dispatch_event(dom_event_target *et, |
| struct dom_event *evt, bool *success) |
| { |
| dom_exception err, ret = DOM_NO_ERR; |
| dom_node_internal *target = (dom_node_internal *) et; |
| dom_document *doc; |
| dom_document_event_internal *dei; |
| dom_event_target **targets; |
| uint32_t ntargets, ntargets_allocated, targetnr; |
| void *pw; |
| assert(et != NULL); |
| assert(evt != NULL); |
| /* To test whether this event is in dispatch */ |
| if (evt->in_dispatch == true) { |
| return DOM_DISPATCH_REQUEST_ERR; |
| } else { |
| evt->in_dispatch = true; |
| } |
| if (evt->type == NULL || dom_string_byte_length(evt->type) == 0) { |
| return DOM_UNSPECIFIED_EVENT_TYPE_ERR; |
| } |
| if (evt->doc == NULL) |
| return DOM_NOT_SUPPORTED_ERR; |
| doc = dom_node_get_owner(et); |
| if (doc == NULL) { |
| /* TODO: In the progress of parsing, many Nodes in the DTD has |
| * no document at all, do nothing for this kind of node */ |
| return DOM_NO_ERR; |
| } |
| *success = true; |
| /* Compose the event target list */ |
| ntargets = 0; |
| ntargets_allocated = 64; |
| targets = calloc(sizeof(*targets), ntargets_allocated); |
| if (targets == NULL) { |
| /** \todo Report memory exhaustion? */ |
| return DOM_NO_ERR; |
| } |
| targets[ntargets++] = (dom_event_target *)dom_node_ref(et); |
| target = target->parent; |
| while (target != NULL) { |
| if (ntargets == ntargets_allocated) { |
| dom_event_target **newtargets = realloc( |
| targets, |
| ntargets_allocated * 2 * sizeof(*targets)); |
| if (newtargets == NULL) |
| goto cleanup; |
| memset(newtargets + ntargets_allocated, |
| 0, ntargets_allocated * sizeof(*newtargets)); |
| targets = newtargets; |
| ntargets_allocated *= 2; |
| } |
| targets[ntargets++] = (dom_event_target *)dom_node_ref(target); |
| target = target->parent; |
| } |
| /* Fill the target of the event */ |
| evt->target = et; |
| evt->phase = DOM_CAPTURING_PHASE; |
| /* The started callback of default action */ |
| dei = &doc->dei; |
| pw = dei->actions_ctx; |
| if (dei->actions != NULL) { |
| dom_default_action_callback cb = dei->actions(evt->type, |
| DOM_DEFAULT_ACTION_STARTED, &pw); |
| if (cb != NULL) { |
| cb(evt, pw); |
| } |
| } |
| /* The capture phase */ |
| for (targetnr = ntargets; targetnr > 0; --targetnr) { |
| dom_node_internal *node = |
| (dom_node_internal *) targets[targetnr - 1]; |
| err = _dom_event_target_dispatch(targets[targetnr - 1], |
| &node->eti, evt, DOM_CAPTURING_PHASE, success); |
| if (err != DOM_NO_ERR) { |
| ret = err; |
| goto cleanup; |
| } |
| /* If the stopImmediatePropagation or stopPropagation is |
| * called, we should break */ |
| if (evt->stop_now == true || evt->stop == true) |
| goto cleanup; |
| } |
| /* Target phase */ |
| evt->phase = DOM_AT_TARGET; |
| evt->current = et; |
| err = _dom_event_target_dispatch(et, &((dom_node_internal *) et)->eti, |
| evt, DOM_AT_TARGET, success); |
| if (err != DOM_NO_ERR) { |
| ret = err; |
| goto cleanup; |
| } |
| if (evt->stop_now == true || evt->stop == true) |
| goto cleanup; |
| /* Bubbling phase */ |
| evt->phase = DOM_BUBBLING_PHASE; |
| for (targetnr = 0; targetnr < ntargets; ++targetnr) { |
| dom_node_internal *node = |
| (dom_node_internal *) targets[targetnr]; |
| err = _dom_event_target_dispatch(targets[targetnr], |
| &node->eti, evt, DOM_BUBBLING_PHASE, success); |
| if (err != DOM_NO_ERR) { |
| ret = err; |
| goto cleanup; |
| } |
| /* If the stopImmediatePropagation or stopPropagation is |
| * called, we should break */ |
| if (evt->stop_now == true || evt->stop == true) |
| goto cleanup; |
| } |
| if (dei->actions == NULL) |
| goto cleanup; |
| /* The end callback of default action */ |
| if (evt->prevent_default != true) { |
| dom_default_action_callback cb = dei->actions(evt->type, |
| DOM_DEFAULT_ACTION_END, &pw); |
| if (cb != NULL) { |
| cb(evt, pw); |
| } |
| } |
| /* The prevented callback of default action */ |
| if (evt->prevent_default != true) { |
| dom_default_action_callback cb = dei->actions(evt->type, |
| DOM_DEFAULT_ACTION_PREVENTED, &pw); |
| if (cb != NULL) { |
| cb(evt, pw); |
| } |
| } |
| cleanup: |
| if (evt->prevent_default == true) { |
| *success = false; |
| } |
| while (ntargets--) { |
| dom_node_unref(targets[ntargets]); |
| } |
| free(targets); |
| return ret; |
| } |
| dom_exception _dom_node_dispatch_node_change_event(dom_document *doc, |
| dom_node_internal *node, dom_node_internal *related, |
| dom_mutation_type change, bool *success) |
| { |
| dom_node_internal *target; |
| dom_exception err; |
| /* Fire change event at immediate target */ |
| err = _dom_dispatch_node_change_event(doc, node, related, |
| change, success); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* Fire document change event at subtree */ |
| target = node->first_child; |
| while (target != NULL) { |
| err = _dom_dispatch_node_change_document_event(doc, target, |
| change, success); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (target->first_child != NULL) { |
| target = target->first_child; |
| } else if (target->next != NULL) { |
| target = target->next; |
| } else { |
| dom_node_internal *parent = target->parent; |
| while (parent != node && target == parent->last_child) { |
| target = parent; |
| parent = target->parent; |
| } |
| target = target->next; |
| } |
| } |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/core/node.h |
|---|
| 0,0 → 1,308 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_node_h_ |
| #define dom_internal_core_node_h_ |
| #include <stdbool.h> |
| #include <libwapcaplet/libwapcaplet.h> |
| #include <dom/core/node.h> |
| #include <dom/functypes.h> |
| #include "events/event_target.h" |
| #include "events/mutation_event.h" |
| #include "utils/list.h" |
| /** |
| * User data context attached to a DOM node |
| */ |
| struct dom_user_data { |
| dom_string *key; /**< Key for data */ |
| void *data; /**< Client-specific data */ |
| dom_user_data_handler handler; /**< Callback function */ |
| struct dom_user_data *next; /**< Next in list */ |
| struct dom_user_data *prev; /**< Previous in list */ |
| }; |
| typedef struct dom_user_data dom_user_data; |
| /** |
| * The internally used virtual function table. |
| */ |
| typedef struct dom_node_protect_vtable { |
| void (*destroy)(dom_node_internal *n); |
| /**< The destroy virtual function, it |
| * should be private to client */ |
| dom_exception (*copy)(dom_node_internal *old, dom_node_internal **copy); |
| /**< Copy the old to new as well as |
| * all its attributes, but not its children */ |
| } dom_node_protect_vtable; |
| /** |
| * The real DOM node object |
| * |
| * DOM nodes are reference counted |
| */ |
| struct dom_node_internal { |
| struct dom_node base; /**< The vtable base */ |
| void *vtable; /**< The protected vtable */ |
| dom_string *name; /**< Node name (this is the local part |
| * of a QName in the cases where a |
| * namespace exists) */ |
| dom_string *value; /**< Node value */ |
| dom_node_type type; /**< Node type */ |
| dom_node_internal *parent; /**< Parent node */ |
| dom_node_internal *first_child; /**< First child node */ |
| dom_node_internal *last_child; /**< Last child node */ |
| dom_node_internal *previous; /**< Previous sibling */ |
| dom_node_internal *next; /**< Next sibling */ |
| struct dom_document *owner; /**< Owning document */ |
| dom_string *namespace; /**< Namespace URI */ |
| dom_string *prefix; /**< Namespace prefix */ |
| struct dom_user_data *user_data; /**< User data list */ |
| struct list_entry pending_list; /**< The document delete pending list */ |
| dom_event_target_internal eti; /**< The EventTarget interface */ |
| }; |
| dom_node_internal * _dom_node_create(void); |
| dom_exception _dom_node_initialise(struct dom_node_internal *node, |
| struct dom_document *doc, dom_node_type type, |
| dom_string *name, dom_string *value, |
| dom_string *namespace, dom_string *prefix); |
| void _dom_node_finalise(dom_node_internal *node); |
| bool _dom_node_readonly(const dom_node_internal *node); |
| /* Event Target implementation */ |
| dom_exception _dom_node_add_event_listener(dom_event_target *et, |
| dom_string *type, struct dom_event_listener *listener, |
| bool capture); |
| dom_exception _dom_node_remove_event_listener(dom_event_target *et, |
| dom_string *type, struct dom_event_listener *listener, |
| bool capture); |
| dom_exception _dom_node_add_event_listener_ns(dom_event_target *et, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, bool capture); |
| dom_exception _dom_node_remove_event_listener_ns(dom_event_target *et, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, bool capture); |
| dom_exception _dom_node_dispatch_event(dom_event_target *et, |
| struct dom_event *evt, bool *success); |
| /* The DOM Node's vtable methods */ |
| dom_exception _dom_node_get_node_name(dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_node_get_node_value(dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_node_set_node_value(dom_node_internal *node, |
| dom_string *value); |
| dom_exception _dom_node_get_node_type(dom_node_internal *node, |
| dom_node_type *result); |
| dom_exception _dom_node_get_parent_node(dom_node_internal *node, |
| dom_node_internal **result); |
| dom_exception _dom_node_get_child_nodes(dom_node_internal *node, |
| struct dom_nodelist **result); |
| dom_exception _dom_node_get_first_child(dom_node_internal *node, |
| dom_node_internal **result); |
| dom_exception _dom_node_get_last_child(dom_node_internal *node, |
| dom_node_internal **result); |
| dom_exception _dom_node_get_previous_sibling(dom_node_internal *node, |
| dom_node_internal **result); |
| dom_exception _dom_node_get_next_sibling(dom_node_internal *node, |
| dom_node_internal **result); |
| dom_exception _dom_node_get_attributes(dom_node_internal *node, |
| struct dom_namednodemap **result); |
| dom_exception _dom_node_get_owner_document(dom_node_internal *node, |
| struct dom_document **result); |
| dom_exception _dom_node_insert_before(dom_node_internal *node, |
| dom_node_internal *new_child, dom_node_internal *ref_child, |
| dom_node_internal **result); |
| dom_exception _dom_node_replace_child(dom_node_internal *node, |
| dom_node_internal *new_child, dom_node_internal *old_child, |
| dom_node_internal **result); |
| dom_exception _dom_node_remove_child(dom_node_internal *node, |
| dom_node_internal *old_child, |
| dom_node_internal **result); |
| dom_exception _dom_node_append_child(dom_node_internal *node, |
| dom_node_internal *new_child, |
| dom_node_internal **result); |
| dom_exception _dom_node_has_child_nodes(dom_node_internal *node, bool *result); |
| dom_exception _dom_node_clone_node(dom_node_internal *node, bool deep, |
| dom_node_internal **result); |
| dom_exception _dom_node_normalize(dom_node_internal *node); |
| dom_exception _dom_node_is_supported(dom_node_internal *node, |
| dom_string *feature, dom_string *version, |
| bool *result); |
| dom_exception _dom_node_get_namespace(dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_node_get_prefix(dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_node_set_prefix(dom_node_internal *node, |
| dom_string *prefix); |
| dom_exception _dom_node_get_local_name(dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_node_has_attributes(dom_node_internal *node, bool *result); |
| dom_exception _dom_node_get_base(dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_node_compare_document_position(dom_node_internal *node, |
| dom_node_internal *other, uint16_t *result); |
| dom_exception _dom_node_get_text_content(dom_node_internal *node, |
| dom_string **result); |
| dom_exception _dom_node_set_text_content(dom_node_internal *node, |
| dom_string *content); |
| dom_exception _dom_node_is_same(dom_node_internal *node, |
| dom_node_internal *other, bool *result); |
| dom_exception _dom_node_lookup_prefix(dom_node_internal *node, |
| dom_string *namespace, dom_string **result); |
| dom_exception _dom_node_is_default_namespace(dom_node_internal *node, |
| dom_string *namespace, bool *result); |
| dom_exception _dom_node_lookup_namespace(dom_node_internal *node, |
| dom_string *prefix, dom_string **result); |
| dom_exception _dom_node_is_equal(dom_node_internal *node, |
| dom_node_internal *other, bool *result); |
| dom_exception _dom_node_get_feature(dom_node_internal *node, |
| dom_string *feature, dom_string *version, |
| void **result); |
| dom_exception _dom_node_set_user_data(dom_node_internal *node, |
| dom_string *key, void *data, |
| dom_user_data_handler handler, void **result); |
| dom_exception _dom_node_get_user_data(dom_node_internal *node, |
| dom_string *key, void **result); |
| #define DOM_NODE_EVENT_TARGET_VTABLE \ |
| _dom_node_add_event_listener, \ |
| _dom_node_remove_event_listener, \ |
| _dom_node_dispatch_event, \ |
| _dom_node_add_event_listener_ns, \ |
| _dom_node_remove_event_listener_ns |
| #define DOM_NODE_VTABLE \ |
| _dom_node_try_destroy, \ |
| _dom_node_get_node_name, \ |
| _dom_node_get_node_value, \ |
| _dom_node_set_node_value, \ |
| _dom_node_get_node_type, \ |
| _dom_node_get_parent_node, \ |
| _dom_node_get_child_nodes, \ |
| _dom_node_get_first_child, \ |
| _dom_node_get_last_child, \ |
| _dom_node_get_previous_sibling, \ |
| _dom_node_get_next_sibling, \ |
| _dom_node_get_attributes, \ |
| _dom_node_get_owner_document, \ |
| _dom_node_insert_before, \ |
| _dom_node_replace_child, \ |
| _dom_node_remove_child, \ |
| _dom_node_append_child, \ |
| _dom_node_has_child_nodes, \ |
| _dom_node_clone_node, \ |
| _dom_node_normalize, \ |
| _dom_node_is_supported, \ |
| _dom_node_get_namespace, \ |
| _dom_node_get_prefix, \ |
| _dom_node_set_prefix, \ |
| _dom_node_get_local_name, \ |
| _dom_node_has_attributes, \ |
| _dom_node_get_base, \ |
| _dom_node_compare_document_position, \ |
| _dom_node_get_text_content, \ |
| _dom_node_set_text_content, \ |
| _dom_node_is_same, \ |
| _dom_node_lookup_prefix, \ |
| _dom_node_is_default_namespace, \ |
| _dom_node_lookup_namespace, \ |
| _dom_node_is_equal, \ |
| _dom_node_get_feature, \ |
| _dom_node_set_user_data, \ |
| _dom_node_get_user_data |
| /* Following comes the protected vtable */ |
| void _dom_node_destroy(struct dom_node_internal *node); |
| dom_exception _dom_node_copy(struct dom_node_internal *old, |
| struct dom_node_internal **copy); |
| #define DOM_NODE_PROTECT_VTABLE \ |
| _dom_node_destroy, \ |
| _dom_node_copy |
| /* The destroy API should be used inside DOM module */ |
| static inline void dom_node_destroy(struct dom_node_internal *node) |
| { |
| ((dom_node_protect_vtable *) node->vtable)->destroy(node); |
| } |
| #define dom_node_destroy(n) dom_node_destroy((dom_node_internal *) (n)) |
| /* Copy the Node old to new */ |
| static inline dom_exception dom_node_copy(struct dom_node_internal *old, |
| struct dom_node_internal **copy) |
| { |
| return ((dom_node_protect_vtable *) old->vtable)->copy(old, copy); |
| } |
| #define dom_node_copy(o,c) dom_node_copy((dom_node_internal *) (o), \ |
| (dom_node_internal **) (c)) |
| /* Following are some helper functions */ |
| dom_exception _dom_node_copy_internal(dom_node_internal *old, |
| dom_node_internal *new); |
| #define dom_node_copy_internal(o, n) _dom_node_copy_internal( \ |
| (dom_node_internal *) (o), (dom_node_internal *) (n)) |
| #define dom_node_get_owner(n) ((dom_node_internal *) (n))->owner |
| #define dom_node_set_owner(n, d) ((dom_node_internal *) (n))->owner = \ |
| (struct dom_document *) (d) |
| #define dom_node_get_parent(n) ((dom_node_internal *) (n))->parent |
| #define dom_node_set_parent(n, p) ((dom_node_internal *) (n))->parent = \ |
| (dom_node_internal *) (p) |
| #define dom_node_get_refcount(n) ((dom_node_internal *) (n))->refcnt |
| dom_exception _dom_merge_adjacent_text(dom_node_internal *p, |
| dom_node_internal *n); |
| /* Try to destroy the node, if its refcnt is not zero, then append it to the |
| * owner document's pending list */ |
| dom_exception _dom_node_try_destroy(dom_node_internal *node); |
| /* To add some node to the pending list */ |
| void _dom_node_mark_pending(dom_node_internal *node); |
| #define dom_node_mark_pending(n) _dom_node_mark_pending(\ |
| (dom_node_internal *) (n)) |
| /* To remove the node from the pending list, this may happen when |
| * a node is removed and then appended to another parent */ |
| void _dom_node_remove_pending(dom_node_internal *node); |
| #define dom_node_remove_pending(n) _dom_node_remove_pending(\ |
| (dom_node_internal *) (n)) |
| dom_exception _dom_node_dispatch_node_change_event(dom_document *doc, |
| dom_node_internal *node, dom_node_internal *related, |
| dom_mutation_type change, bool *success); |
| #define dom_node_dispatch_node_change_event( \ |
| doc, node, related, change, success) \ |
| _dom_node_dispatch_node_change_event((dom_document *) (doc), \ |
| (dom_node_internal *) (node), \ |
| (dom_node_internal *) (related), \ |
| (dom_mutation_type) (change), \ |
| (bool *) (success)) |
| #endif |
| /contrib/network/netsurf/libdom/src/core/nodelist.c |
|---|
| 0,0 → 1,455 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/core/node.h> |
| #include <dom/core/document.h> |
| #include <dom/core/nodelist.h> |
| #include <dom/core/string.h> |
| #include "core/document.h" |
| #include "core/node.h" |
| #include "core/nodelist.h" |
| #include "utils/utils.h" |
| /** |
| * DOM node list |
| */ |
| struct dom_nodelist { |
| dom_document *owner; /**< Owning document */ |
| dom_node_internal *root; |
| /**< Root of applicable subtree */ |
| nodelist_type type; /**< Type of this list */ |
| union { |
| struct { |
| dom_string *name; |
| /**< Tag name to match */ |
| bool any_name; /**< The name is '*' */ |
| } n; |
| struct { |
| bool any_namespace; /**< The namespace is '*' */ |
| bool any_localname; /**< The localname is '*' */ |
| dom_string *namespace; /**< Namespace */ |
| dom_string *localname; /**< Localname */ |
| } ns; /**< Data for namespace matching */ |
| } data; |
| uint32_t refcnt; /**< Reference count */ |
| }; |
| /** |
| * Create a nodelist |
| * |
| * \param doc Owning document |
| * \param type The type of the NodeList |
| * \param root Root node of subtree that list applies to |
| * \param tagname Name of nodes in list (or NULL) |
| * \param namespace Namespace part of nodes in list (or NULL) |
| * \param localname Local part of nodes in list (or NULL) |
| * \param list Pointer to location to receive list |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion |
| * |
| * ::root must be a node owned by ::doc |
| * |
| * The returned list will already be referenced, so the client need not |
| * do so explicitly. The client must unref the list once finished with it. |
| */ |
| dom_exception _dom_nodelist_create(dom_document *doc, nodelist_type type, |
| dom_node_internal *root, dom_string *tagname, |
| dom_string *namespace, dom_string *localname, |
| dom_nodelist **list) |
| { |
| dom_nodelist *l; |
| l = malloc(sizeof(dom_nodelist)); |
| if (l == NULL) |
| return DOM_NO_MEM_ERR; |
| dom_node_ref(doc); |
| l->owner = doc; |
| dom_node_ref(root); |
| l->root = root; |
| l->type = type; |
| if (type == DOM_NODELIST_BY_NAME || |
| type == DOM_NODELIST_BY_NAME_CASELESS) { |
| assert(tagname != NULL); |
| l->data.n.any_name = false; |
| if (dom_string_byte_length(tagname) == 1) { |
| const char *ch = dom_string_data(tagname); |
| if (*ch == '*') { |
| l->data.n.any_name = true; |
| } |
| } |
| l->data.n.name = dom_string_ref(tagname); |
| } else if (type == DOM_NODELIST_BY_NAMESPACE || |
| type == DOM_NODELIST_BY_NAMESPACE_CASELESS) { |
| l->data.ns.any_localname = false; |
| l->data.ns.any_namespace = false; |
| if (localname != NULL) { |
| if (dom_string_byte_length(localname) == 1) { |
| const char *ch = dom_string_data(localname); |
| if (*ch == '*') { |
| l->data.ns.any_localname = true; |
| } |
| } |
| dom_string_ref(localname); |
| } |
| if (namespace != NULL) { |
| if (dom_string_byte_length(namespace) == 1) { |
| const char *ch = dom_string_data(namespace); |
| if (*ch == '*') { |
| l->data.ns.any_namespace = true; |
| } |
| } |
| dom_string_ref(namespace); |
| } |
| l->data.ns.namespace = namespace; |
| l->data.ns.localname = localname; |
| } |
| l->refcnt = 1; |
| *list = l; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Claim a reference on a DOM node list |
| * |
| * \param list The list to claim a reference on |
| */ |
| void dom_nodelist_ref(dom_nodelist *list) |
| { |
| assert(list != NULL); |
| list->refcnt++; |
| } |
| /** |
| * Release a reference on a DOM node list |
| * |
| * \param list The list to release the reference from |
| * |
| * If the reference count reaches zero, any memory claimed by the |
| * list will be released |
| */ |
| void dom_nodelist_unref(dom_nodelist *list) |
| { |
| if (list == NULL) |
| return; |
| if (--list->refcnt == 0) { |
| dom_node_internal *owner = (dom_node_internal *) list->owner; |
| switch (list->type) { |
| case DOM_NODELIST_CHILDREN: |
| /* Nothing to do */ |
| break; |
| case DOM_NODELIST_BY_NAMESPACE: |
| case DOM_NODELIST_BY_NAMESPACE_CASELESS: |
| if (list->data.ns.namespace != NULL) |
| dom_string_unref(list->data.ns.namespace); |
| if (list->data.ns.localname != NULL) |
| dom_string_unref(list->data.ns.localname); |
| break; |
| case DOM_NODELIST_BY_NAME: |
| case DOM_NODELIST_BY_NAME_CASELESS: |
| assert(list->data.n.name != NULL); |
| dom_string_unref(list->data.n.name); |
| break; |
| } |
| dom_node_unref(list->root); |
| /* Remove list from document */ |
| _dom_document_remove_nodelist(list->owner, list); |
| /* Destroy the list object */ |
| free(list); |
| /* And release our reference on the owning document |
| * This must be last as, otherwise, it's possible that |
| * the document is destroyed before we are */ |
| dom_node_unref(owner); |
| } |
| } |
| /** |
| * Retrieve the length of a node list |
| * |
| * \param list List to retrieve length of |
| * \param length Pointer to location to receive length |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception dom_nodelist_get_length(dom_nodelist *list, uint32_t *length) |
| { |
| dom_node_internal *cur = list->root->first_child; |
| uint32_t len = 0; |
| /* Traverse data structure */ |
| while (cur != NULL) { |
| /* Process current node */ |
| if (list->type == DOM_NODELIST_CHILDREN) { |
| len++; |
| } else if (list->type == DOM_NODELIST_BY_NAME) { |
| if (list->data.n.any_name == true || ( |
| cur->name != NULL && |
| dom_string_isequal(cur->name, |
| list->data.n.name))) { |
| if (cur->type == DOM_ELEMENT_NODE) |
| len++; |
| } |
| } else if (list->type == DOM_NODELIST_BY_NAME_CASELESS) { |
| if (list->data.n.any_name == true || ( |
| cur->name != NULL && |
| dom_string_caseless_isequal(cur->name, |
| list->data.n.name))) { |
| if (cur->type == DOM_ELEMENT_NODE) |
| len++; |
| } |
| } else if (list->type == DOM_NODELIST_BY_NAMESPACE) { |
| if (list->data.ns.any_namespace == true || |
| dom_string_isequal(cur->namespace, |
| list->data.ns.namespace)) { |
| if (list->data.ns.any_localname == true || |
| (cur->name != NULL && |
| dom_string_isequal(cur->name, |
| list->data.ns.localname))) { |
| if (cur->type == DOM_ELEMENT_NODE) |
| len++; |
| } |
| } |
| } else if (list->type == DOM_NODELIST_BY_NAMESPACE_CASELESS) { |
| if (list->data.ns.any_namespace == true || |
| dom_string_caseless_isequal( |
| cur->namespace, |
| list->data.ns.namespace)) { |
| if (list->data.ns.any_localname == true || |
| (cur->name != NULL && |
| dom_string_caseless_isequal( |
| cur->name, |
| list->data.ns.localname))) { |
| if (cur->type == DOM_ELEMENT_NODE) |
| len++; |
| } |
| } |
| } else { |
| assert("Unknown list type" == NULL); |
| } |
| /* Now, find next node */ |
| if (list->type == DOM_NODELIST_CHILDREN) { |
| /* Just interested in sibling list */ |
| cur = cur->next; |
| } else { |
| /* Want a full in-order tree traversal */ |
| if (cur->first_child != NULL) { |
| /* Has children */ |
| cur = cur->first_child; |
| } else if (cur->next != NULL) { |
| /* No children, but has siblings */ |
| cur = cur->next; |
| } else { |
| /* No children or siblings. |
| * Find first unvisited relation. */ |
| dom_node_internal *parent = cur->parent; |
| while (parent != list->root && |
| cur == parent->last_child) { |
| cur = parent; |
| parent = parent->parent; |
| } |
| cur = cur->next; |
| } |
| } |
| } |
| *length = len; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve an item from a node list |
| * |
| * \param list The list to retrieve the item from |
| * \param index The list index to retrieve |
| * \param node Pointer to location to receive item |
| * \return DOM_NO_ERR. |
| * |
| * ::index is a zero-based index into ::list. |
| * ::index lies in the range [0, length-1] |
| * |
| * The returned node will have had its reference count increased. The client |
| * should unref the node once it has finished with it. |
| */ |
| dom_exception _dom_nodelist_item(dom_nodelist *list, |
| uint32_t index, dom_node **node) |
| { |
| dom_node_internal *cur = list->root->first_child; |
| uint32_t count = 0; |
| /* Traverse data structure */ |
| while (cur != NULL) { |
| /* Process current node */ |
| if (list->type == DOM_NODELIST_CHILDREN) { |
| count++; |
| } else if (list->type == DOM_NODELIST_BY_NAME) { |
| if (list->data.n.any_name == true || ( |
| cur->name != NULL && |
| dom_string_isequal(cur->name, |
| list->data.n.name))) { |
| if (cur->type == DOM_ELEMENT_NODE) |
| count++; |
| } |
| } else if (list->type == DOM_NODELIST_BY_NAME_CASELESS) { |
| if (list->data.n.any_name == true || ( |
| cur->name != NULL && |
| dom_string_caseless_isequal(cur->name, |
| list->data.n.name))) { |
| if (cur->type == DOM_ELEMENT_NODE) |
| count++; |
| } |
| } else if (list->type == DOM_NODELIST_BY_NAMESPACE) { |
| if (list->data.ns.any_namespace == true || |
| (cur->namespace != NULL && |
| dom_string_isequal(cur->namespace, |
| list->data.ns.namespace))) { |
| if (list->data.ns.any_localname == true || |
| (cur->name != NULL && |
| dom_string_isequal(cur->name, |
| list->data.ns.localname))) { |
| if (cur->type == DOM_ELEMENT_NODE) |
| count++; |
| } |
| } |
| } else if (list->type == DOM_NODELIST_BY_NAMESPACE_CASELESS) { |
| if (list->data.ns.any_namespace == true || |
| (cur->namespace != NULL && |
| dom_string_caseless_isequal( |
| cur->namespace, |
| list->data.ns.namespace))) { |
| if (list->data.ns.any_localname == true || |
| (cur->name != NULL && |
| dom_string_caseless_isequal( |
| cur->name, |
| list->data.ns.localname))) { |
| if (cur->type == DOM_ELEMENT_NODE) |
| count++; |
| } |
| } |
| } else { |
| assert("Unknown list type" == NULL); |
| } |
| /* Stop if this is the requested index */ |
| if ((index + 1) == count) { |
| break; |
| } |
| /* Now, find next node */ |
| if (list->type == DOM_NODELIST_CHILDREN) { |
| /* Just interested in sibling list */ |
| cur = cur->next; |
| } else { |
| /* Want a full in-order tree traversal */ |
| if (cur->first_child != NULL) { |
| /* Has children */ |
| cur = cur->first_child; |
| } else if (cur->next != NULL) { |
| /* No children, but has siblings */ |
| cur = cur->next; |
| } else { |
| /* No children or siblings. |
| * Find first unvisited relation. */ |
| dom_node_internal *parent = cur->parent; |
| while (parent != list->root && |
| cur == parent->last_child) { |
| cur = parent; |
| parent = parent->parent; |
| } |
| cur = cur->next; |
| } |
| } |
| } |
| if (cur != NULL) { |
| dom_node_ref(cur); |
| } |
| *node = (dom_node *) cur; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Match a nodelist instance against a set of nodelist creation parameters |
| * |
| * \param list List to match |
| * \param type The type of the NodeList |
| * \param root Root node of subtree that list applies to |
| * \param tagname Name of nodes in list (or NULL) |
| * \param namespace Namespace part of nodes in list (or NULL) |
| * \param localname Local part of nodes in list (or NULL) |
| * \return true if list matches, false otherwise |
| */ |
| bool _dom_nodelist_match(dom_nodelist *list, nodelist_type type, |
| dom_node_internal *root, dom_string *tagname, |
| dom_string *namespace, dom_string *localname) |
| { |
| if (list->root != root) |
| return false; |
| if (list->type != type) |
| return false; |
| switch (list->type) { |
| case DOM_NODELIST_CHILDREN: |
| return true; |
| case DOM_NODELIST_BY_NAME: |
| return dom_string_isequal(list->data.n.name, tagname); |
| case DOM_NODELIST_BY_NAMESPACE: |
| return dom_string_isequal(list->data.ns.namespace, namespace) && |
| dom_string_isequal(list->data.ns.localname, localname); |
| case DOM_NODELIST_BY_NAME_CASELESS: |
| return dom_string_caseless_isequal(list->data.n.name, tagname); |
| case DOM_NODELIST_BY_NAMESPACE_CASELESS: |
| return dom_string_caseless_isequal(list->data.ns.namespace, |
| namespace) && |
| dom_string_caseless_isequal(list->data.ns.localname, |
| localname); |
| } |
| return false; |
| } |
| /** |
| * Test whether the two NodeList are equal |
| * |
| * \param l1 One list |
| * \param l2 The other list |
| * \reutrn true for equal, false otherwise. |
| */ |
| bool _dom_nodelist_equal(dom_nodelist *l1, dom_nodelist *l2) |
| { |
| return _dom_nodelist_match(l1, l1->type, l2->root, l2->data.n.name, |
| l2->data.ns.namespace, l2->data.ns.localname); |
| } |
| /contrib/network/netsurf/libdom/src/core/nodelist.h |
|---|
| 0,0 → 1,45 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_nodelist_h_ |
| #define dom_internal_core_nodelist_h_ |
| #include <stdbool.h> |
| #include <dom/core/nodelist.h> |
| struct dom_document; |
| struct dom_node; |
| struct dom_nodelist; |
| /** |
| * The NodeList type |
| */ |
| typedef enum { |
| DOM_NODELIST_CHILDREN, |
| DOM_NODELIST_BY_NAME, |
| DOM_NODELIST_BY_NAMESPACE, |
| DOM_NODELIST_BY_NAME_CASELESS, |
| DOM_NODELIST_BY_NAMESPACE_CASELESS |
| } nodelist_type; |
| /* Create a nodelist */ |
| dom_exception _dom_nodelist_create(struct dom_document *doc, nodelist_type type, |
| struct dom_node_internal *root, dom_string *tagname, |
| dom_string *namespace, dom_string *localname, |
| struct dom_nodelist **list); |
| /* Match a nodelist instance against a set of nodelist creation parameters */ |
| bool _dom_nodelist_match(struct dom_nodelist *list, nodelist_type type, |
| struct dom_node_internal *root, dom_string *tagname, |
| dom_string *namespace, dom_string *localname); |
| bool _dom_nodelist_equal(struct dom_nodelist *l1, struct dom_nodelist *l2); |
| #define dom_nodelist_equal(l1, l2) _dom_nodelist_equal( \ |
| (struct dom_nodelist *) (l1), (struct dom_nodelist *) (l2)) |
| #endif |
| /contrib/network/netsurf/libdom/src/core/pi.c |
|---|
| 0,0 → 1,123 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #include <stdlib.h> |
| #include "core/document.h" |
| #include "core/node.h" |
| #include "core/pi.h" |
| #include "utils/utils.h" |
| /** |
| * A DOM processing instruction |
| */ |
| struct dom_processing_instruction { |
| dom_node_internal base; /**< Base node */ |
| }; |
| static struct dom_node_vtable pi_vtable = { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE |
| }, |
| DOM_NODE_VTABLE |
| }; |
| static struct dom_node_protect_vtable pi_protect_vtable = { |
| DOM_PI_PROTECT_VTABLE |
| }; |
| /** |
| * Create a processing instruction |
| * |
| * \param doc The owning document |
| * \param name The name of the node to create |
| * \param value The text content of the node |
| * \param result Pointer to location to receive created node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * ::doc, ::name and ::value will have their reference counts increased. |
| * |
| * The returned node will already be referenced. |
| */ |
| dom_exception _dom_processing_instruction_create(dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_processing_instruction **result) |
| { |
| dom_processing_instruction *p; |
| dom_exception err; |
| /* Allocate the comment node */ |
| p = malloc(sizeof(dom_processing_instruction)); |
| if (p == NULL) |
| return DOM_NO_MEM_ERR; |
| p->base.base.vtable = &pi_vtable; |
| p->base.vtable = &pi_protect_vtable; |
| /* And initialise the node */ |
| err = _dom_processing_instruction_initialise(&p->base, doc, |
| DOM_PROCESSING_INSTRUCTION_NODE, |
| name, value, NULL, NULL); |
| if (err != DOM_NO_ERR) { |
| free(p); |
| return err; |
| } |
| *result = p; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Destroy a processing instruction |
| * |
| * \param pi The processing instruction to destroy |
| * |
| * The contents of ::pi will be destroyed and ::pi will be freed. |
| */ |
| void _dom_processing_instruction_destroy(dom_processing_instruction *pi) |
| { |
| /* Finalise base class */ |
| _dom_processing_instruction_finalise(&pi->base); |
| /* Free processing instruction */ |
| free(pi); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Following comes the protected vtable */ |
| /* The virtual destroy function of this class */ |
| void _dom_pi_destroy(dom_node_internal *node) |
| { |
| _dom_processing_instruction_destroy( |
| (dom_processing_instruction *) node); |
| } |
| /* The copy constructor of this class */ |
| dom_exception _dom_pi_copy(dom_node_internal *old, dom_node_internal **copy) |
| { |
| dom_processing_instruction *new_pi; |
| dom_exception err; |
| new_pi = malloc(sizeof(dom_processing_instruction)); |
| if (new_pi == NULL) |
| return DOM_NO_MEM_ERR; |
| err = dom_node_copy_internal(old, new_pi); |
| if (err != DOM_NO_ERR) { |
| free(new_pi); |
| return err; |
| } |
| *copy = (dom_node_internal *) copy; |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/core/pi.h |
|---|
| 0,0 → 1,31 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_processinginstruction_h_ |
| #define dom_internal_core_processinginstruction_h_ |
| #include <dom/core/exceptions.h> |
| #include <dom/core/pi.h> |
| dom_exception _dom_processing_instruction_create(dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_processing_instruction **result); |
| void _dom_processing_instruction_destroy(dom_processing_instruction *pi); |
| #define _dom_processing_instruction_initialise _dom_node_initialise |
| #define _dom_processing_instruction_finalise _dom_node_finalise |
| /* Following comes the protected vtable */ |
| void _dom_pi_destroy(dom_node_internal *node); |
| dom_exception _dom_pi_copy(dom_node_internal *old, dom_node_internal **copy); |
| #define DOM_PI_PROTECT_VTABLE \ |
| _dom_pi_destroy, \ |
| _dom_pi_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/core/string.c |
|---|
| 0,0 → 1,1029 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <ctype.h> |
| #include <inttypes.h> |
| #include <stdlib.h> |
| #include <string.h> |
| typedef signed char int8_t; |
| typedef signed short int16_t; |
| typedef signed int int32_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short uint16_t; |
| typedef unsigned int uint32_t; |
| #include <parserutils/charset/utf8.h> |
| #include "core/string.h" |
| #include "core/document.h" |
| #include "utils/utils.h" |
| /** |
| * Type of a DOM string |
| */ |
| enum dom_string_type { |
| DOM_STRING_CDATA = 0, |
| DOM_STRING_INTERNED = 1 |
| }; |
| /** |
| * A DOM string |
| * |
| * Strings are reference counted so destruction is performed correctly. |
| */ |
| typedef struct dom_string_internal { |
| dom_string base; |
| union { |
| struct { |
| uint8_t *ptr; /**< Pointer to string data */ |
| size_t len; /**< Byte length of string */ |
| } cdata; |
| lwc_string *intern; /**< Interned string */ |
| } data; |
| enum dom_string_type type; /**< String type */ |
| } dom_string_internal; |
| /** |
| * Empty string, for comparisons against NULL |
| */ |
| static const dom_string_internal empty_string = { |
| { 0 }, |
| { { (uint8_t *) "", 0 } }, |
| DOM_STRING_CDATA |
| }; |
| void dom_string_destroy(dom_string *str) |
| { |
| dom_string_internal *istr = (dom_string_internal *)str; |
| if (str != NULL) { |
| assert(istr->base.refcnt == 0); |
| switch (istr->type) { |
| case DOM_STRING_INTERNED: |
| if (istr->data.intern != NULL) { |
| lwc_string_unref(istr->data.intern); |
| } |
| break; |
| case DOM_STRING_CDATA: |
| free(istr->data.cdata.ptr); |
| break; |
| } |
| free(str); |
| } |
| } |
| /** |
| * Create a DOM string from a string of characters |
| * |
| * \param ptr Pointer to string of characters |
| * \param len Length, in bytes, of string of characters |
| * \param str Pointer to location to receive result |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion |
| * |
| * The returned string will already be referenced, so there is no need |
| * to explicitly reference it. |
| * |
| * The string of characters passed in will be copied for use by the |
| * returned DOM string. |
| */ |
| dom_exception dom_string_create(const uint8_t *ptr, size_t len, |
| dom_string **str) |
| { |
| dom_string_internal *ret; |
| if (ptr == NULL || len == 0) { |
| ptr = (const uint8_t *) ""; |
| len = 0; |
| } |
| ret = malloc(sizeof(*ret)); |
| if (ret == NULL) |
| return DOM_NO_MEM_ERR; |
| ret->data.cdata.ptr = malloc(len + 1); |
| if (ret->data.cdata.ptr == NULL) { |
| free(ret); |
| return DOM_NO_MEM_ERR; |
| } |
| memcpy(ret->data.cdata.ptr, ptr, len); |
| ret->data.cdata.ptr[len] = '\0'; |
| ret->data.cdata.len = len; |
| ret->base.refcnt = 1; |
| ret->type = DOM_STRING_CDATA; |
| *str = (dom_string *)ret; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Create an interned DOM string from a string of characters |
| * |
| * \param ptr Pointer to string of characters |
| * \param len Length, in bytes, of string of characters |
| * \param str Pointer to location to receive result |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion |
| * |
| * The returned string will already be referenced, so there is no need |
| * to explicitly reference it. |
| * |
| * The string of characters passed in will be copied for use by the |
| * returned DOM string. |
| */ |
| dom_exception dom_string_create_interned(const uint8_t *ptr, size_t len, |
| dom_string **str) |
| { |
| dom_string_internal *ret; |
| if (ptr == NULL || len == 0) { |
| ptr = (const uint8_t *) ""; |
| len = 0; |
| } |
| ret = malloc(sizeof(*ret)); |
| if (ret == NULL) |
| return DOM_NO_MEM_ERR; |
| if (lwc_intern_string((const char *) ptr, len, |
| &ret->data.intern) != lwc_error_ok) { |
| free(ret); |
| return DOM_NO_MEM_ERR; |
| } |
| ret->base.refcnt = 1; |
| ret->type = DOM_STRING_INTERNED; |
| *str = (dom_string *)ret; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Make the dom_string be interned |
| * |
| * \param str The dom_string to be interned |
| * \param lwcstr The result lwc_string |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_string_intern(dom_string *str, |
| struct lwc_string_s **lwcstr) |
| { |
| dom_string_internal *istr = (dom_string_internal *) str; |
| /* If this string is already interned, do nothing */ |
| if (istr->type != DOM_STRING_INTERNED) { |
| lwc_string *ret; |
| lwc_error lerr; |
| lerr = lwc_intern_string((const char *) istr->data.cdata.ptr, |
| istr->data.cdata.len, &ret); |
| if (lerr != lwc_error_ok) { |
| return _dom_exception_from_lwc_error(lerr); |
| } |
| free(istr->data.cdata.ptr); |
| istr->data.intern = ret; |
| istr->type = DOM_STRING_INTERNED; |
| } |
| *lwcstr = lwc_string_ref(istr->data.intern); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Case sensitively compare two DOM strings |
| * |
| * \param s1 The first string to compare |
| * \param s2 The second string to compare |
| * \return true if strings match, false otherwise |
| */ |
| bool dom_string_isequal(const dom_string *s1, const dom_string *s2) |
| { |
| size_t len; |
| const dom_string_internal *is1 = (dom_string_internal *) s1; |
| const dom_string_internal *is2 = (dom_string_internal *) s2; |
| if (s1 == NULL) |
| is1 = &empty_string; |
| if (s2 == NULL) |
| is2 = &empty_string; |
| if (is1->type == DOM_STRING_INTERNED && |
| is2->type == DOM_STRING_INTERNED) { |
| bool match; |
| (void) lwc_string_isequal(is1->data.intern, is2->data.intern, |
| &match); |
| return match; |
| } |
| len = dom_string_byte_length((dom_string *) is1); |
| if (len != dom_string_byte_length((dom_string *)is2)) |
| return false; |
| return 0 == memcmp(dom_string_data((dom_string *) is1), dom_string_data((dom_string *)is2), len); |
| } |
| /** |
| * Trivial locale-agnostic lower case convertor |
| */ |
| static inline uint8_t dolower(const uint8_t c) |
| { |
| if ('A' <= c && c <= 'Z') |
| return c + 'a' - 'A'; |
| return c; |
| } |
| /** |
| * Case insensitively compare two DOM strings |
| * |
| * \param s1 The first string to compare |
| * \param s2 The second string to compare |
| * \return true if strings match, false otherwise |
| */ |
| bool dom_string_caseless_isequal(const dom_string *s1, const dom_string *s2) |
| { |
| const uint8_t *d1 = NULL; |
| const uint8_t *d2 = NULL; |
| size_t len; |
| const dom_string_internal *is1 = (dom_string_internal *) s1; |
| const dom_string_internal *is2 = (dom_string_internal *) s2; |
| if (s1 == NULL) |
| is1 = &empty_string; |
| if (s2 == NULL) |
| is2 = &empty_string; |
| if (is1->type == DOM_STRING_INTERNED && |
| is2->type == DOM_STRING_INTERNED) { |
| bool match; |
| if (lwc_string_caseless_isequal(is1->data.intern, is2->data.intern, |
| &match) != lwc_error_ok) |
| return false; |
| return match; |
| } |
| len = dom_string_byte_length((dom_string *) is1); |
| if (len != dom_string_byte_length((dom_string *)is2)) |
| return false; |
| d1 = (const uint8_t *) dom_string_data((dom_string *) is1); |
| d2 = (const uint8_t *) dom_string_data((dom_string *)is2); |
| while (len > 0) { |
| if (dolower(*d1) != dolower(*d2)) |
| return false; |
| d1++; |
| d2++; |
| len--; |
| } |
| return true; |
| } |
| /** |
| * Case sensitively compare DOM string with lwc_string |
| * |
| * \param s1 The first string to compare |
| * \param s2 The second string to compare |
| * \return true if strings match, false otherwise |
| * |
| * Returns false if either are NULL. |
| */ |
| bool dom_string_lwc_isequal(const dom_string *s1, lwc_string *s2) |
| { |
| size_t len; |
| dom_string_internal *is1 = (dom_string_internal *) s1; |
| if (s1 == NULL || s2 == NULL) |
| return false; |
| if (is1->type == DOM_STRING_INTERNED) { |
| bool match; |
| (void) lwc_string_isequal(is1->data.intern, s2, &match); |
| return match; |
| } |
| /* Handle non-interned case */ |
| len = dom_string_byte_length(s1); |
| if (len != lwc_string_length(s2)) |
| return false; |
| return 0 == memcmp(dom_string_data(s1), lwc_string_data(s2), len); |
| } |
| /** |
| * Case insensitively compare DOM string with lwc_string |
| * |
| * \param s1 The first string to compare |
| * \param s2 The second string to compare |
| * \return true if strings match, false otherwise |
| * |
| * Returns false if either are NULL. |
| */ |
| bool dom_string_caseless_lwc_isequal(const dom_string *s1, lwc_string *s2) |
| { |
| size_t len; |
| const uint8_t *d1 = NULL; |
| const uint8_t *d2 = NULL; |
| dom_string_internal *is1 = (dom_string_internal *) s1; |
| if (s1 == NULL || s2 == NULL) |
| return false; |
| if (is1->type == DOM_STRING_INTERNED) { |
| bool match; |
| if (lwc_string_caseless_isequal(is1->data.intern, s2, &match) != lwc_error_ok) |
| return false; |
| return match; |
| } |
| len = dom_string_byte_length(s1); |
| if (len != lwc_string_length(s2)) |
| return false; |
| d1 = (const uint8_t *) dom_string_data(s1); |
| d2 = (const uint8_t *) lwc_string_data(s2); |
| while (len > 0) { |
| if (dolower(*d1) != dolower(*d2)) |
| return false; |
| d1++; |
| d2++; |
| len--; |
| } |
| return true; |
| } |
| /** |
| * Get the index of the first occurrence of a character in a dom string |
| * |
| * \param str The string to search in |
| * \param chr UCS4 value to look for |
| * \return Character index of found character, or -1 if none found |
| */ |
| uint32_t dom_string_index(dom_string *str, uint32_t chr) |
| { |
| const uint8_t *s; |
| size_t clen, slen; |
| uint32_t c, index; |
| parserutils_error err; |
| s = (const uint8_t *) dom_string_data(str); |
| slen = dom_string_byte_length(str); |
| index = 0; |
| while (slen > 0) { |
| err = parserutils_charset_utf8_to_ucs4(s, slen, &c, &clen); |
| if (err != PARSERUTILS_OK) { |
| return (uint32_t) -1; |
| } |
| if (c == chr) { |
| return index; |
| } |
| s += clen; |
| slen -= clen; |
| index++; |
| } |
| return (uint32_t) -1; |
| } |
| /** |
| * Get the index of the last occurrence of a character in a dom string |
| * |
| * \param str The string to search in |
| * \param chr UCS4 value to look for |
| * \return Character index of found character, or -1 if none found |
| */ |
| uint32_t dom_string_rindex(dom_string *str, uint32_t chr) |
| { |
| const uint8_t *s; |
| size_t clen = 0, slen; |
| uint32_t c, coff, index; |
| parserutils_error err; |
| s = (const uint8_t *) dom_string_data(str); |
| slen = dom_string_byte_length(str); |
| index = dom_string_length(str); |
| while (slen > 0) { |
| err = parserutils_charset_utf8_prev(s, slen, |
| (uint32_t *) &coff); |
| if (err == PARSERUTILS_OK) { |
| err = parserutils_charset_utf8_to_ucs4(s + coff, |
| slen - clen, &c, &clen); |
| } |
| if (err != PARSERUTILS_OK) { |
| return (uint32_t) -1; |
| } |
| if (c == chr) { |
| return index; |
| } |
| slen -= clen; |
| index--; |
| } |
| return (uint32_t) -1; |
| } |
| /** |
| * Get the length, in characters, of a dom string |
| * |
| * \param str The string to measure the length of |
| * \return The length of the string, in characters |
| */ |
| uint32_t dom_string_length(dom_string *str) |
| { |
| const uint8_t *s; |
| size_t slen, clen; |
| parserutils_error err; |
| s = (const uint8_t *) dom_string_data(str); |
| slen = dom_string_byte_length(str); |
| err = parserutils_charset_utf8_length(s, slen, &clen); |
| if (err != PARSERUTILS_OK) { |
| return 0; |
| } |
| return clen; |
| } |
| /** |
| * Get the UCS4 character at position index |
| * |
| * \param index The position of the charater |
| * \param ch The UCS4 character |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_string_at(dom_string *str, uint32_t index, |
| uint32_t *ch) |
| { |
| const uint8_t *s; |
| size_t clen, slen; |
| uint32_t c, i; |
| parserutils_error err; |
| s = (const uint8_t *) dom_string_data(str); |
| slen = dom_string_byte_length(str); |
| i = 0; |
| while (slen > 0) { |
| err = parserutils_charset_utf8_char_byte_length(s, &clen); |
| if (err != PARSERUTILS_OK) { |
| return (uint32_t) -1; |
| } |
| i++; |
| if (i == index + 1) |
| break; |
| s += clen; |
| slen -= clen; |
| } |
| if (i == index + 1) { |
| err = parserutils_charset_utf8_to_ucs4(s, slen, &c, &clen); |
| if (err != PARSERUTILS_OK) { |
| return (uint32_t) -1; |
| } |
| *ch = c; |
| return DOM_NO_ERR; |
| } else { |
| return DOM_DOMSTRING_SIZE_ERR; |
| } |
| } |
| /** |
| * Concatenate two dom strings |
| * |
| * \param s1 The first string |
| * \param s2 The second string |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion |
| * |
| * The returned string will be referenced. The client |
| * should dereference it once it has finished with it. |
| */ |
| dom_exception dom_string_concat(dom_string *s1, dom_string *s2, |
| dom_string **result) |
| { |
| dom_string_internal *concat; |
| const uint8_t *s1ptr, *s2ptr; |
| size_t s1len, s2len; |
| assert(s1 != NULL); |
| assert(s2 != NULL); |
| s1ptr = (const uint8_t *) dom_string_data(s1); |
| s2ptr = (const uint8_t *) dom_string_data(s2); |
| s1len = dom_string_byte_length(s1); |
| s2len = dom_string_byte_length(s2); |
| concat = malloc(sizeof(*concat)); |
| if (concat == NULL) { |
| return DOM_NO_MEM_ERR; |
| } |
| concat->data.cdata.ptr = malloc(s1len + s2len + 1); |
| if (concat->data.cdata.ptr == NULL) { |
| free(concat); |
| return DOM_NO_MEM_ERR; |
| } |
| memcpy(concat->data.cdata.ptr, s1ptr, s1len); |
| memcpy(concat->data.cdata.ptr + s1len, s2ptr, s2len); |
| concat->data.cdata.ptr[s1len + s2len] = '\0'; |
| concat->data.cdata.len = s1len + s2len; |
| concat->base.refcnt = 1; |
| concat->type = DOM_STRING_CDATA; |
| *result = (dom_string *)concat; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Extract a substring from a dom string |
| * |
| * \param str The string to extract from |
| * \param i1 The character index of the start of the substring |
| * \param i2 The character index of the end of the substring |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion |
| * |
| * The returned string will have its reference count increased. The client |
| * should dereference it once it has finished with it. |
| */ |
| dom_exception dom_string_substr(dom_string *str, |
| uint32_t i1, uint32_t i2, dom_string **result) |
| { |
| const uint8_t *s = (const uint8_t *) dom_string_data(str); |
| size_t slen = dom_string_byte_length(str); |
| uint32_t b1, b2; |
| parserutils_error err; |
| /* Initialise the byte index of the start to 0 */ |
| b1 = 0; |
| /* Make the end a character offset from the start */ |
| i2 -= i1; |
| /* Calculate the byte index of the start */ |
| while (i1 > 0) { |
| err = parserutils_charset_utf8_next(s, slen, b1, &b1); |
| if (err != PARSERUTILS_OK) { |
| return DOM_NO_MEM_ERR; |
| } |
| i1--; |
| } |
| /* Initialise the byte index of the end to that of the start */ |
| b2 = b1; |
| /* Calculate the byte index of the end */ |
| while (i2 > 0) { |
| err = parserutils_charset_utf8_next(s, slen, b2, &b2); |
| if (err != PARSERUTILS_OK) { |
| return DOM_NO_MEM_ERR; |
| } |
| i2--; |
| } |
| /* Create a string from the specified byte range */ |
| return dom_string_create(s + b1, b2 - b1, result); |
| } |
| /** |
| * Insert data into a dom string at the given location |
| * |
| * \param target Pointer to string to insert into |
| * \param source Pointer to string to insert |
| * \param offset Character offset of location to insert at |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEM_ERR on memory exhaustion, |
| * DOM_INDEX_SIZE_ERR if ::offset > len(::target). |
| * |
| * The returned string will have its reference count increased. The client |
| * should dereference it once it has finished with it. |
| */ |
| dom_exception dom_string_insert(dom_string *target, |
| dom_string *source, uint32_t offset, |
| dom_string **result) |
| { |
| dom_string_internal *res; |
| const uint8_t *t, *s; |
| uint32_t tlen, slen, clen; |
| uint32_t ins = 0; |
| parserutils_error err; |
| t = (const uint8_t *) dom_string_data(target); |
| tlen = dom_string_byte_length(target); |
| s = (const uint8_t *) dom_string_data(source); |
| slen = dom_string_byte_length(source); |
| clen = dom_string_length(target); |
| if (offset > clen) |
| return DOM_INDEX_SIZE_ERR; |
| /* Calculate the byte index of the insertion point */ |
| if (offset == clen) { |
| /* Optimisation for append */ |
| ins = tlen; |
| } else { |
| while (offset > 0) { |
| err = parserutils_charset_utf8_next(t, tlen, |
| ins, &ins); |
| if (err != PARSERUTILS_OK) { |
| return DOM_NO_MEM_ERR; |
| } |
| offset--; |
| } |
| } |
| /* Allocate result string */ |
| res = malloc(sizeof(*res)); |
| if (res == NULL) { |
| return DOM_NO_MEM_ERR; |
| } |
| /* Allocate data buffer for result contents */ |
| res->data.cdata.ptr = malloc(tlen + slen + 1); |
| if (res->data.cdata.ptr == NULL) { |
| free(res); |
| return DOM_NO_MEM_ERR; |
| } |
| /* Copy initial portion of target, if any, into result */ |
| if (ins > 0) { |
| memcpy(res->data.cdata.ptr, t, ins); |
| } |
| /* Copy inserted data into result */ |
| memcpy(res->data.cdata.ptr + ins, s, slen); |
| /* Copy remainder of target, if any, into result */ |
| if (tlen - ins > 0) { |
| memcpy(res->data.cdata.ptr + ins + slen, t + ins, tlen - ins); |
| } |
| res->data.cdata.ptr[tlen + slen] = '\0'; |
| res->data.cdata.len = tlen + slen; |
| res->base.refcnt = 1; |
| res->type = DOM_STRING_CDATA; |
| *result = (dom_string *)res; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Replace a section of a dom string |
| * |
| * \param target Pointer to string of which to replace a section |
| * \param source Pointer to replacement string |
| * \param i1 Character index of start of region to replace |
| * \param i2 Character index of end of region to replace |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * The returned string will have its reference count increased. The client |
| * should dereference it once it has finished with it. |
| */ |
| dom_exception dom_string_replace(dom_string *target, |
| dom_string *source, uint32_t i1, uint32_t i2, |
| dom_string **result) |
| { |
| dom_string_internal *res; |
| const uint8_t *t, *s; |
| uint32_t tlen, slen; |
| uint32_t b1, b2; |
| parserutils_error err; |
| t = (const uint8_t *) dom_string_data(target); |
| tlen = dom_string_byte_length(target); |
| s = (const uint8_t *) dom_string_data(source); |
| slen = dom_string_byte_length(source); |
| /* Initialise the byte index of the start to 0 */ |
| b1 = 0; |
| /* Make the end a character offset from the start */ |
| i2 -= i1; |
| /* Calculate the byte index of the start */ |
| while (i1 > 0) { |
| err = parserutils_charset_utf8_next(t, tlen, b1, &b1); |
| if (err != PARSERUTILS_OK) { |
| return DOM_NO_MEM_ERR; |
| } |
| i1--; |
| } |
| /* Initialise the byte index of the end to that of the start */ |
| b2 = b1; |
| /* Calculate the byte index of the end */ |
| while (i2 > 0) { |
| err = parserutils_charset_utf8_next(t, tlen, b2, &b2); |
| if (err != PARSERUTILS_OK) { |
| return DOM_NO_MEM_ERR; |
| } |
| i2--; |
| } |
| /* Allocate result string */ |
| res = malloc(sizeof(*res)); |
| if (res == NULL) { |
| return DOM_NO_MEM_ERR; |
| } |
| /* Allocate data buffer for result contents */ |
| res->data.cdata.ptr = malloc(tlen + slen - (b2 - b1) + 1); |
| if (res->data.cdata.ptr == NULL) { |
| free(res); |
| return DOM_NO_MEM_ERR; |
| } |
| /* Copy initial portion of target, if any, into result */ |
| if (b1 > 0) { |
| memcpy(res->data.cdata.ptr, t, b1); |
| } |
| /* Copy replacement data into result */ |
| if (slen > 0) { |
| memcpy(res->data.cdata.ptr + b1, s, slen); |
| } |
| /* Copy remainder of target, if any, into result */ |
| if (tlen - b2 > 0) { |
| memcpy(res->data.cdata.ptr + b1 + slen, t + b2, tlen - b2); |
| } |
| res->data.cdata.ptr[tlen + slen - (b2 - b1)] = '\0'; |
| res->data.cdata.len = tlen + slen - (b2 - b1); |
| res->base.refcnt = 1; |
| res->type = DOM_STRING_CDATA; |
| *result = (dom_string *)res; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Calculate a hash value from a dom string |
| * |
| * \param str The string to calculate a hash of |
| * \return The hash value associated with the string |
| */ |
| uint32_t dom_string_hash(dom_string *str) |
| { |
| const uint8_t *s = (const uint8_t *) dom_string_data(str); |
| size_t slen = dom_string_byte_length(str); |
| uint32_t hash = 0x811c9dc5; |
| while (slen > 0) { |
| hash *= 0x01000193; |
| hash ^= *s; |
| s++; |
| slen--; |
| } |
| return hash; |
| } |
| /** |
| * Convert a lwc_error to a dom_exception |
| * |
| * \param err The input lwc_error |
| * \return the dom_exception |
| */ |
| dom_exception _dom_exception_from_lwc_error(lwc_error err) |
| { |
| switch (err) { |
| case lwc_error_ok: |
| return DOM_NO_ERR; |
| case lwc_error_oom: |
| return DOM_NO_MEM_ERR; |
| case lwc_error_range: |
| return DOM_INDEX_SIZE_ERR; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the raw character data of the dom_string. |
| * |
| * \param str The dom_string object |
| * \return The C string pointer |
| * |
| * @note: This function is just provided for the convenience of accessing the |
| * raw C string character, no change on the result string is allowed. |
| */ |
| const char *dom_string_data(const dom_string *str) |
| { |
| dom_string_internal *istr = (dom_string_internal *) str; |
| if (istr->type == DOM_STRING_CDATA) { |
| return (const char *) istr->data.cdata.ptr; |
| } else { |
| return lwc_string_data(istr->data.intern); |
| } |
| } |
| /** Get the byte length of this dom_string |
| * |
| * \param str The dom_string object |
| */ |
| size_t dom_string_byte_length(const dom_string *str) |
| { |
| dom_string_internal *istr = (dom_string_internal *) str; |
| if (istr->type == DOM_STRING_CDATA) { |
| return istr->data.cdata.len; |
| } else { |
| return lwc_string_length(istr->data.intern); |
| } |
| } |
| /** Convert the given string to uppercase |
| * |
| * \param source |
| * \param ascii_only Whether to only convert [a-z] to [A-Z] |
| * \param upper Result pointer for uppercase string. Caller owns ref |
| * |
| * \return DOM_NO_ERR on success. |
| * |
| * \note Right now, will return DOM_NOT_SUPPORTED_ERR if ascii_only is false. |
| */ |
| dom_exception |
| dom_string_toupper(dom_string *source, bool ascii_only, dom_string **upper) |
| { |
| const uint8_t *orig_s = (const uint8_t *) dom_string_data(source); |
| const size_t nbytes = dom_string_byte_length(source); |
| uint8_t *copy_s; |
| size_t index = 0, clen; |
| parserutils_error err; |
| dom_exception exc; |
| if (ascii_only == false) |
| return DOM_NOT_SUPPORTED_ERR; |
| copy_s = malloc(nbytes); |
| if (copy_s == NULL) |
| return DOM_NO_MEM_ERR; |
| memcpy(copy_s, orig_s, nbytes); |
| while (index < nbytes) { |
| err = parserutils_charset_utf8_char_byte_length(orig_s + index, |
| &clen); |
| if (err != PARSERUTILS_OK) { |
| free(copy_s); |
| /** \todo Find a better exception */ |
| return DOM_NO_MEM_ERR; |
| } |
| if (clen == 1) { |
| if (orig_s[index] >= 'a' && |
| orig_s[index] <= 'z') |
| copy_s[index] -= 'a' - 'A'; |
| } |
| index += clen; |
| } |
| if (((dom_string_internal*)source)->type == DOM_STRING_CDATA) { |
| exc = dom_string_create(copy_s, nbytes, upper); |
| } else { |
| exc = dom_string_create_interned(copy_s, nbytes, upper); |
| } |
| free(copy_s); |
| return exc; |
| } |
| /** Convert the given string to lowercase |
| * |
| * \param source |
| * \param ascii_only Whether to only convert [a-z] to [A-Z] |
| * \param lower Result pointer for lowercase string. Caller owns ref |
| * |
| * \return DOM_NO_ERR on success. |
| * |
| * \note Right now, will return DOM_NOT_SUPPORTED_ERR if ascii_only is false. |
| */ |
| dom_exception |
| dom_string_tolower(dom_string *source, bool ascii_only, dom_string **lower) |
| { |
| const uint8_t *orig_s = (const uint8_t *) dom_string_data(source); |
| const size_t nbytes = dom_string_byte_length(source); |
| uint8_t *copy_s; |
| size_t index = 0, clen; |
| parserutils_error err; |
| dom_exception exc; |
| if (ascii_only == false) |
| return DOM_NOT_SUPPORTED_ERR; |
| copy_s = malloc(nbytes); |
| if (copy_s == NULL) |
| return DOM_NO_MEM_ERR; |
| memcpy(copy_s, orig_s, nbytes); |
| while (index < nbytes) { |
| err = parserutils_charset_utf8_char_byte_length(orig_s + index, |
| &clen); |
| if (err != PARSERUTILS_OK) { |
| free(copy_s); |
| /** \todo Find a better exception */ |
| return DOM_NO_MEM_ERR; |
| } |
| if (clen == 1) { |
| if (orig_s[index] >= 'A' && |
| orig_s[index] <= 'Z') |
| copy_s[index] += 'a' - 'A'; |
| } |
| index += clen; |
| } |
| if (((dom_string_internal*)source)->type == DOM_STRING_CDATA) { |
| exc = dom_string_create(copy_s, nbytes, lower); |
| } else { |
| exc = dom_string_create_interned(copy_s, nbytes, lower); |
| } |
| free(copy_s); |
| return exc; |
| } |
| /contrib/network/netsurf/libdom/src/core/string.h |
|---|
| 0,0 → 1,18 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_core_string_h_ |
| #define dom_internal_core_string_h_ |
| #include <dom/core/string.h> |
| /* Map the lwc_error to dom_exception */ |
| dom_exception _dom_exception_from_lwc_error(lwc_error err); |
| #endif |
| /contrib/network/netsurf/libdom/src/core/text.c |
|---|
| 0,0 → 1,524 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/core/string.h> |
| #include <dom/core/text.h> |
| #include <libwapcaplet/libwapcaplet.h> |
| #include "core/characterdata.h" |
| #include "core/document.h" |
| #include "core/text.h" |
| #include "utils/utils.h" |
| /* The virtual table for dom_text */ |
| struct dom_text_vtable text_vtable = { |
| { |
| { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE, |
| }, |
| DOM_NODE_VTABLE_CHARACTERDATA |
| }, |
| DOM_CHARACTERDATA_VTABLE |
| }, |
| DOM_TEXT_VTABLE |
| }; |
| static struct dom_node_protect_vtable text_protect_vtable = { |
| DOM_TEXT_PROTECT_VTABLE |
| }; |
| /* Following comes helper functions */ |
| typedef enum walk_operation { |
| COLLECT, |
| DELETE |
| } walk_operation; |
| typedef enum walk_order { |
| LEFT, |
| RIGHT |
| } walk_order; |
| /* Walk the logic-adjacent text in document order */ |
| static dom_exception walk_logic_adjacent_text_in_order( |
| dom_node_internal *node, walk_operation opt, |
| walk_order order, dom_string **ret, bool *cont); |
| /* Walk the logic-adjacent text */ |
| static dom_exception walk_logic_adjacent_text(dom_text *text, |
| walk_operation opt, dom_string **ret); |
| /*----------------------------------------------------------------------*/ |
| /* Constructor and Destructor */ |
| /** |
| * Create a text node |
| * |
| * \param doc The owning document |
| * \param name The name of the node to create |
| * \param value The text content of the node |
| * \param result Pointer to location to receive created node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MEM_ERR on memory exhaustion. |
| * |
| * ::doc, ::name and ::value will have their reference counts increased. |
| * |
| * The returned node will already be referenced. |
| */ |
| dom_exception _dom_text_create(dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_text **result) |
| { |
| dom_text *t; |
| dom_exception err; |
| /* Allocate the text node */ |
| t = malloc(sizeof(dom_text)); |
| if (t == NULL) |
| return DOM_NO_MEM_ERR; |
| /* And initialise the node */ |
| err = _dom_text_initialise(t, doc, DOM_TEXT_NODE, name, value); |
| if (err != DOM_NO_ERR) { |
| free(t); |
| return err; |
| } |
| /* Compose the vtable */ |
| ((dom_node *) t)->vtable = &text_vtable; |
| ((dom_node_internal *) t)->vtable = &text_protect_vtable; |
| *result = t; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Destroy a text node |
| * |
| * \param doc The owning document |
| * \param text The text node to destroy |
| * |
| * The contents of ::text will be destroyed and ::text will be freed. |
| */ |
| void _dom_text_destroy(dom_text *text) |
| { |
| /* Finalise node */ |
| _dom_text_finalise(text); |
| /* Free node */ |
| free(text); |
| } |
| /** |
| * Initialise a text node |
| * |
| * \param text The node to initialise |
| * \param doc The owning document |
| * \param type The type of the node |
| * \param name The name of the node to create |
| * \param value The text content of the node |
| * \return DOM_NO_ERR on success. |
| * |
| * ::doc, ::name and ::value will have their reference counts increased. |
| */ |
| dom_exception _dom_text_initialise(dom_text *text, |
| dom_document *doc, dom_node_type type, |
| dom_string *name, dom_string *value) |
| { |
| dom_exception err; |
| /* Initialise the base class */ |
| err = _dom_characterdata_initialise(&text->base, doc, type, |
| name, value); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* Perform our type-specific initialisation */ |
| text->element_content_whitespace = false; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Finalise a text node |
| * |
| * \param doc The owning document |
| * \param text The text node to finalise |
| * |
| * The contents of ::text will be cleaned up. ::text will not be freed. |
| */ |
| void _dom_text_finalise(dom_text *text) |
| { |
| _dom_characterdata_finalise(&text->base); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public virtual functions */ |
| /** |
| * Split a text node at a given character offset |
| * |
| * \param text The node to split |
| * \param offset Character offset to split at |
| * \param result Pointer to location to receive new node |
| * \return DOM_NO_ERR on success, |
| * DOM_INDEX_SIZE_ERR if ::offset is greater than the |
| * number of characters in ::text, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if ::text is readonly. |
| * |
| * The returned node will be referenced. The client should unref the node |
| * once it has finished with it. |
| */ |
| dom_exception _dom_text_split_text(dom_text *text, |
| uint32_t offset, dom_text **result) |
| { |
| dom_node_internal *t = (dom_node_internal *) text; |
| dom_string *value; |
| dom_text *res; |
| uint32_t len; |
| dom_exception err; |
| if (_dom_node_readonly(t)) { |
| return DOM_NO_MODIFICATION_ALLOWED_ERR; |
| } |
| err = dom_characterdata_get_length(&text->base, &len); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| if (offset >= len) { |
| return DOM_INDEX_SIZE_ERR; |
| } |
| /* Retrieve the data after the split point -- |
| * this will be the new node's value. */ |
| err = dom_characterdata_substring_data(&text->base, offset, |
| len - offset, &value); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Create new node */ |
| err = _dom_text_create(t->owner, t->name, value, &res); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(value); |
| return err; |
| } |
| /* Release our reference on the value (the new node has its own) */ |
| dom_string_unref(value); |
| /* Delete the data after the split point */ |
| err = dom_characterdata_delete_data(&text->base, offset, len - offset); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(res); |
| return err; |
| } |
| *result = res; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Determine if a text node contains element content whitespace |
| * |
| * \param text The node to consider |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_text_get_is_element_content_whitespace( |
| dom_text *text, bool *result) |
| { |
| *result = text->element_content_whitespace; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Retrieve all text in Text nodes logically adjacent to a Text node |
| * |
| * \param text Text node to consider |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_text_get_whole_text(dom_text *text, |
| dom_string **result) |
| { |
| return walk_logic_adjacent_text(text, COLLECT, result); |
| } |
| /** |
| * Replace the text of a Text node and all logically adjacent Text nodes |
| * |
| * \param text Text node to consider |
| * \param content Replacement content |
| * \param result Pointer to location to receive Text node |
| * \return DOM_NO_ERR on success, |
| * DOM_NO_MODIFICATION_ALLOWED_ERR if one of the Text nodes being |
| * replaced is readonly. |
| * |
| * The returned node will be referenced. The client should unref the node |
| * once it has finished with it. |
| */ |
| dom_exception _dom_text_replace_whole_text(dom_text *text, |
| dom_string *content, dom_text **result) |
| { |
| dom_exception err; |
| dom_string *ret; |
| err = walk_logic_adjacent_text(text, DELETE, &ret); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_characterdata_set_data(text, content); |
| if (err != DOM_NO_ERR) |
| return err; |
| *result = text; |
| dom_node_ref(text); |
| return DOM_NO_ERR; |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The destroy function of this class */ |
| void __dom_text_destroy(dom_node_internal *node) |
| { |
| _dom_text_destroy((dom_text *) node); |
| } |
| /* The copy constructor of this class */ |
| dom_exception _dom_text_copy(dom_node_internal *old, dom_node_internal **copy) |
| { |
| dom_text *new_text; |
| dom_exception err; |
| new_text = malloc(sizeof(dom_text)); |
| if (new_text == NULL) |
| return DOM_NO_MEM_ERR; |
| err = dom_text_copy_internal(old, new_text); |
| if (err != DOM_NO_ERR) { |
| free(new_text); |
| return err; |
| } |
| *copy = (dom_node_internal *) new_text; |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_text_copy_internal(dom_text *old, dom_text *new) |
| { |
| dom_exception err; |
| err = dom_characterdata_copy_internal(old, new); |
| if (err != DOM_NO_ERR) |
| return err; |
| new->element_content_whitespace = old->element_content_whitespace; |
| return DOM_NO_ERR; |
| } |
| /*----------------------------------------------------------------------*/ |
| /* Helper functions */ |
| /** |
| * Walk the logic adjacent text in certain order |
| * |
| * \param node The start Text node |
| * \param opt The operation on each Text Node |
| * \param order The order |
| * \param ret The string of the logic adjacent text |
| * \param cont Whether the logic adjacent text is interrupt here |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception walk_logic_adjacent_text_in_order( |
| dom_node_internal *node, walk_operation opt, |
| walk_order order, dom_string **ret, bool *cont) |
| { |
| dom_exception err; |
| dom_string *data, *tmp; |
| dom_node_internal *parent; |
| /* If we reach the leaf of the DOM tree, just return to continue |
| * to next sibling of our parent */ |
| if (node == NULL) { |
| *cont = true; |
| return DOM_NO_ERR; |
| } |
| parent = dom_node_get_parent(node); |
| while (node != NULL) { |
| dom_node_internal *p; |
| /* If we reach the boundary of logical-adjacent text, we stop */ |
| if (node->type == DOM_ELEMENT_NODE || |
| node->type == DOM_COMMENT_NODE || |
| node->type == |
| DOM_PROCESSING_INSTRUCTION_NODE) { |
| *cont = false; |
| return DOM_NO_ERR; |
| } |
| if (node->type == DOM_TEXT_NODE) { |
| /* According the DOM spec, text node never have child */ |
| assert(node->first_child == NULL); |
| assert(node->last_child == NULL); |
| if (opt == COLLECT) { |
| err = dom_characterdata_get_data(node, &data); |
| if (err == DOM_NO_ERR) |
| return err; |
| tmp = *ret; |
| if (order == LEFT) { |
| err = dom_string_concat(data, tmp, ret); |
| if (err == DOM_NO_ERR) |
| return err; |
| } else if (order == RIGHT) { |
| err = dom_string_concat(tmp, data, ret); |
| if (err == DOM_NO_ERR) |
| return err; |
| } |
| dom_string_unref(tmp); |
| dom_string_unref(data); |
| *cont = true; |
| return DOM_NO_ERR; |
| } |
| if (opt == DELETE) { |
| dom_node_internal *tn; |
| err = dom_node_remove_child(node->parent, |
| node, (void *) &tn); |
| if (err != DOM_NO_ERR) |
| return err; |
| *cont = true; |
| dom_node_unref(tn); |
| return DOM_NO_ERR; |
| } |
| } |
| p = dom_node_get_parent(node); |
| if (order == LEFT) { |
| if (node->last_child != NULL) { |
| node = node->last_child; |
| } else if (node->previous != NULL) { |
| node = node->previous; |
| } else { |
| while (p != parent && node == p->last_child) { |
| node = p; |
| p = dom_node_get_parent(p); |
| } |
| node = node->previous; |
| } |
| } else { |
| if (node->first_child != NULL) { |
| node = node->first_child; |
| } else if (node->next != NULL) { |
| node = node->next; |
| } else { |
| while (p != parent && node == p->first_child) { |
| node = p; |
| p = dom_node_get_parent(p); |
| } |
| node = node->next; |
| } |
| } |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Traverse the logic adjacent text. |
| * |
| * \param text The Text Node from which we start traversal |
| * \param opt The operation code |
| * \param ret The returned string if the opt is COLLECT |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception walk_logic_adjacent_text(dom_text *text, |
| walk_operation opt, dom_string **ret) |
| { |
| dom_node_internal *node = (dom_node_internal *) text; |
| dom_node_internal *parent = node->parent; |
| dom_node_internal *left = node->previous; |
| dom_node_internal *right = node->next; |
| dom_exception err; |
| bool cont; |
| if (parent->type == DOM_ENTITY_NODE) { |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| *ret = NULL; |
| /* Firstly, we look our left */ |
| err = walk_logic_adjacent_text_in_order(left, opt, LEFT, ret, &cont); |
| if (err != DOM_NO_ERR) { |
| if (opt == COLLECT) { |
| dom_string_unref(*ret); |
| *ret = NULL; |
| } |
| return err; |
| } |
| /* Ourself */ |
| if (opt == COLLECT) { |
| dom_string *data = NULL, *tmp = NULL; |
| err = dom_characterdata_get_data(text, &data); |
| if (err == DOM_NO_ERR) { |
| dom_string_unref(*ret); |
| return err; |
| } |
| err = dom_string_concat(*ret, data, &tmp); |
| if (err == DOM_NO_ERR) { |
| dom_string_unref(*ret); |
| return err; |
| } |
| dom_string_unref(*ret); |
| dom_string_unref(data); |
| *ret = tmp; |
| } else { |
| dom_node_internal *tn; |
| err = dom_node_remove_child(node->parent, node, |
| (void *) &tn); |
| if (err != DOM_NO_ERR) |
| return err; |
| dom_node_unref(tn); |
| } |
| /* Now, look right */ |
| err = walk_logic_adjacent_text_in_order(right, opt, RIGHT, ret, &cont); |
| if (err != DOM_NO_ERR) { |
| if (opt == COLLECT) { |
| dom_string_unref(*ret); |
| *ret = NULL; |
| } |
| return err; |
| } |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/core/text.h |
|---|
| 0,0 → 1,75 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_core_text_h_ |
| #define dom_internal_core_text_h_ |
| #include <stdbool.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/text.h> |
| #include "core/characterdata.h" |
| struct dom_document; |
| /** |
| * A DOM text node |
| */ |
| struct dom_text { |
| dom_characterdata base; /**< Base node */ |
| bool element_content_whitespace; /**< This node is element |
| * content whitespace */ |
| }; |
| /* Constructor and Destructor */ |
| dom_exception _dom_text_create(struct dom_document *doc, |
| dom_string *name, dom_string *value, |
| dom_text **result); |
| void _dom_text_destroy(dom_text *text); |
| dom_exception _dom_text_initialise(dom_text *text, |
| struct dom_document *doc, dom_node_type type, |
| dom_string *name, dom_string *value); |
| void _dom_text_finalise(dom_text *text); |
| /* Virtual functions for dom_text */ |
| dom_exception _dom_text_split_text(dom_text *text, |
| uint32_t offset, dom_text **result); |
| dom_exception _dom_text_get_is_element_content_whitespace( |
| dom_text *text, bool *result); |
| dom_exception _dom_text_get_whole_text(dom_text *text, |
| dom_string **result); |
| dom_exception _dom_text_replace_whole_text(dom_text *text, |
| dom_string *content, dom_text **result); |
| #define DOM_TEXT_VTABLE \ |
| _dom_text_split_text, \ |
| _dom_text_get_is_element_content_whitespace, \ |
| _dom_text_get_whole_text, \ |
| _dom_text_replace_whole_text |
| /* Following comes the protected vtable */ |
| void __dom_text_destroy(struct dom_node_internal *node); |
| dom_exception _dom_text_copy(dom_node_internal *old, dom_node_internal **copy); |
| #define DOM_TEXT_PROTECT_VTABLE \ |
| __dom_text_destroy, \ |
| _dom_text_copy |
| extern struct dom_text_vtable text_vtable; |
| dom_exception _dom_text_copy_internal(dom_text *old, dom_text *new); |
| #define dom_text_copy_internal(o, n) \ |
| _dom_text_copy_internal((dom_text *) (o), (dom_text *) (n)) |
| #endif |
| /contrib/network/netsurf/libdom/src/core/typeinfo.c |
|---|
| 0,0 → 1,80 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <dom/core/typeinfo.h> |
| #include <dom/core/string.h> |
| #include "utils/utils.h" |
| /* TypeInfo object */ |
| struct dom_type_info { |
| struct lwc_string_s *type; /**< Type name */ |
| struct lwc_string_s *namespace; /**< Type namespace */ |
| }; |
| /** |
| * Get the type name of this dom_type_info |
| * |
| * \param ti The dom_type_info |
| * \param ret The name |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * We don't support this API now, so this function call always |
| * return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_type_info_get_type_name(dom_type_info *ti, |
| dom_string **ret) |
| { |
| UNUSED(ti); |
| UNUSED(ret); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Get the namespace of this type info |
| * |
| * \param ti The dom_type_info |
| * \param ret The namespace |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * We don't support this API now, so this function call always |
| * return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_type_info_get_type_namespace(dom_type_info *ti, |
| dom_string **ret) |
| { |
| UNUSED(ti); |
| UNUSED(ret); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Whether this type info is derived from another one |
| * |
| * \param ti The dom_type_info |
| * \param namespace The namespace of name |
| * \param name The name of the base typeinfo |
| * \param method The deriving method |
| * \param ret The return value |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * We don't support this API now, so this function call always |
| * return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_type_info_is_derived(dom_type_info *ti, |
| dom_string *namespace, dom_string *name, |
| dom_type_info_derivation_method method, bool *ret) |
| { |
| UNUSED(ti); |
| UNUSED(namespace); |
| UNUSED(name); |
| UNUSED(method); |
| UNUSED(ret); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/events/Makefile |
|---|
| 0,0 → 1,10 |
| OBJS := event.o dispatch.o event_target.o document_event.o \ |
| custom_event.o keyboard_event.o mouse_wheel_event.o \ |
| text_event.o event_listener.o mouse_event.o mutation_event.o \ |
| ui_event.o mouse_multi_wheel_event.o mutation_name_event.o |
| OUTFILE = libo.o |
| CFLAGS += -I ../../include/ -I ../../ -I ../ -I ./ -I /home/sourcerer/kos_src/newenginek/kolibri/include |
| include $(MENUETDEV)/makefiles/Makefile_for_o_lib |
| /contrib/network/netsurf/libdom/src/events/custom_event.c |
|---|
| 0,0 → 1,99 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "events/custom_event.h" |
| #include "core/document.h" |
| static void _virtual_dom_custom_event_destroy(struct dom_event *evt); |
| static struct dom_event_private_vtable _event_vtable = { |
| _virtual_dom_custom_event_destroy |
| }; |
| /* Constructor */ |
| dom_exception _dom_custom_event_create(struct dom_document *doc, |
| struct dom_custom_event **evt) |
| { |
| *evt = malloc(sizeof(dom_custom_event)); |
| if (*evt == NULL) |
| return DOM_NO_MEM_ERR; |
| ((struct dom_event *) *evt)->vtable = &_event_vtable; |
| return _dom_custom_event_initialise(doc, *evt); |
| } |
| /* Destructor */ |
| void _dom_custom_event_destroy(struct dom_custom_event *evt) |
| { |
| _dom_custom_event_finalise(evt); |
| free(evt); |
| } |
| /* Initialise function */ |
| dom_exception _dom_custom_event_initialise(struct dom_document *doc, |
| struct dom_custom_event *evt) |
| { |
| evt->detail = NULL; |
| return _dom_event_initialise(doc, &evt->base); |
| } |
| /* Finalise function */ |
| void _dom_custom_event_finalise(struct dom_custom_event *evt) |
| { |
| evt->detail = NULL; |
| _dom_event_finalise(&evt->base); |
| } |
| /* The virtual destroy function */ |
| void _virtual_dom_custom_event_destroy(struct dom_event *evt) |
| { |
| _dom_custom_event_destroy((dom_custom_event *) evt); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Get the detail object of this custom event |
| * |
| * \param evt The Event object |
| * \param detail The returned detail object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_custom_event_get_detail(dom_custom_event *evt, |
| void **detail) |
| { |
| *detail = evt->detail; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Initialise this custom event |
| * |
| * \param evt The Event object |
| * \param namespace The namespace of this new Event |
| * \param type The Event type |
| * \param bubble Whether this event can bubble |
| * \param cancelable Whether this event is cancelable |
| * \param detail The detail object of this custom event |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_custom_event_init_ns(dom_custom_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, void *detail) |
| { |
| evt->detail = detail; |
| return _dom_event_init_ns(&evt->base, namespace, type, bubble, |
| cancelable); |
| } |
| /contrib/network/netsurf/libdom/src/events/custom_event.h |
|---|
| 0,0 → 1,34 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_interntal_events_custom_event_h_ |
| #define dom_interntal_events_custom_event_h_ |
| #include <dom/events/custom_event.h> |
| #include "events/event.h" |
| struct dom_custom_event { |
| struct dom_event base; |
| void *detail; |
| }; |
| /* Constructor */ |
| dom_exception _dom_custom_event_create(struct dom_document *doc, |
| struct dom_custom_event **evt); |
| /* Destructor */ |
| void _dom_custom_event_destroy(struct dom_custom_event *evt); |
| /* Initialise function */ |
| dom_exception _dom_custom_event_initialise(struct dom_document *doc, |
| struct dom_custom_event *evt); |
| /* Finalise function */ |
| void _dom_custom_event_finalise(struct dom_custom_event *evt); |
| #endif |
| /contrib/network/netsurf/libdom/src/events/dispatch.c |
|---|
| 0,0 → 1,268 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include "core/document.h" |
| #include "events/dispatch.h" |
| #include "events/mutation_event.h" |
| #include "utils/utils.h" |
| /** |
| * Dispatch a DOMNodeInserted/DOMNodeRemoved event |
| * |
| * \param doc The document object |
| * \param et The EventTarget object |
| * \param type "DOMNodeInserted" or "DOMNodeRemoved" |
| * \param related The parent of the removed/inserted node |
| * \param success Whether this event's default action get called |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception __dom_dispatch_node_change_event(dom_document *doc, |
| dom_event_target *et, dom_event_target *related, |
| dom_mutation_type change, bool *success) |
| { |
| struct dom_mutation_event *evt; |
| dom_string *type = NULL; |
| dom_exception err; |
| err = _dom_mutation_event_create(doc, &evt); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (change == DOM_MUTATION_ADDITION) { |
| type = dom_string_ref(doc->_memo_domnodeinserted); |
| } else if (change == DOM_MUTATION_REMOVAL) { |
| type = dom_string_ref(doc->_memo_domnoderemoved); |
| } else { |
| assert("Should never be here" == NULL); |
| } |
| /* Initialise the event with corresponding parameters */ |
| err = dom_mutation_event_init(evt, type, true, false, |
| related, NULL, NULL, NULL, change); |
| dom_string_unref(type); |
| if (err != DOM_NO_ERR) { |
| goto cleanup; |
| } |
| err = dom_event_target_dispatch_event(et, evt, success); |
| if (err != DOM_NO_ERR) |
| goto cleanup; |
| cleanup: |
| _dom_mutation_event_destroy(evt); |
| return err; |
| } |
| /** |
| * Dispatch a DOMNodeInsertedIntoDocument/DOMNodeRemovedFromDocument event |
| * |
| * \param doc The document object |
| * \param et The EventTarget object |
| * \param type "DOMNodeInserted" or "DOMNodeRemoved" |
| * \param success Whether this event's default action get called |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception __dom_dispatch_node_change_document_event(dom_document *doc, |
| dom_event_target *et, dom_mutation_type change, bool *success) |
| { |
| struct dom_mutation_event *evt; |
| dom_string *type = NULL; |
| dom_exception err; |
| err = _dom_mutation_event_create(doc, &evt); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (change == DOM_MUTATION_ADDITION) { |
| type = dom_string_ref(doc->_memo_domnodeinsertedintodocument); |
| } else if (change == DOM_MUTATION_REMOVAL) { |
| type = dom_string_ref(doc->_memo_domnoderemovedfromdocument); |
| } else { |
| assert("Should never be here" == NULL); |
| } |
| /* Initialise the event with corresponding parameters */ |
| err = dom_mutation_event_init(evt, type, true, false, NULL, |
| NULL, NULL, NULL, change); |
| dom_string_unref(type); |
| if (err != DOM_NO_ERR) |
| goto cleanup; |
| err = dom_event_target_dispatch_event(et, evt, success); |
| if (err != DOM_NO_ERR) |
| goto cleanup; |
| cleanup: |
| _dom_mutation_event_destroy(evt); |
| return err; |
| } |
| /** |
| * Dispatch a DOMAttrModified event |
| * |
| * \param doc The Document object |
| * \param et The EventTarget |
| * \param prev The previous value before change |
| * \param new The new value after change |
| * \param related The related EventTarget |
| * \param attr_name The Attribute name |
| * \param change How this attribute change |
| * \param success Whether this event's default handler get called |
| * \return DOM_NO_ERR on success, appropirate dom_exception on failure. |
| */ |
| dom_exception __dom_dispatch_attr_modified_event(dom_document *doc, |
| dom_event_target *et, dom_string *prev, dom_string *new, |
| dom_event_target *related, dom_string *attr_name, |
| dom_mutation_type change, bool *success) |
| { |
| struct dom_mutation_event *evt; |
| dom_string *type = NULL; |
| dom_exception err; |
| err = _dom_mutation_event_create(doc, &evt); |
| if (err != DOM_NO_ERR) |
| return err; |
| type = dom_string_ref(doc->_memo_domattrmodified); |
| /* Initialise the event with corresponding parameters */ |
| err = dom_mutation_event_init(evt, type, true, false, related, |
| prev, new, attr_name, change); |
| dom_string_unref(type); |
| if (err != DOM_NO_ERR) { |
| goto cleanup; |
| } |
| err = dom_event_target_dispatch_event(et, evt, success); |
| cleanup: |
| _dom_mutation_event_destroy(evt); |
| return err; |
| } |
| /** |
| * Dispatch a DOMCharacterDataModified event |
| * |
| * \param et The EventTarget object |
| * \param prev The preValue of the DOMCharacterData |
| * \param new The newValue of the DOMCharacterData |
| * \param success Whether this event's default handler get called |
| * \return DOM_NO_ERR on success, appropirate dom_exception on failure. |
| * |
| * TODO: |
| * The character_data object may be a part of a Attr node, if so, another |
| * DOMAttrModified event should be dispatched, too. But for now, we did not |
| * support any XML feature, so just leave it as this. |
| */ |
| dom_exception __dom_dispatch_characterdata_modified_event( |
| dom_document *doc, dom_event_target *et, |
| dom_string *prev, dom_string *new, bool *success) |
| { |
| struct dom_mutation_event *evt; |
| dom_string *type = NULL; |
| dom_exception err; |
| err = _dom_mutation_event_create(doc, &evt); |
| if (err != DOM_NO_ERR) |
| return err; |
| type = dom_string_ref(doc->_memo_domcharacterdatamodified); |
| err = dom_mutation_event_init(evt, type, true, false, et, prev, |
| new, NULL, DOM_MUTATION_MODIFICATION); |
| dom_string_unref(type); |
| if (err != DOM_NO_ERR) { |
| goto cleanup; |
| } |
| err = dom_event_target_dispatch_event(et, evt, success); |
| cleanup: |
| _dom_mutation_event_destroy(evt); |
| return err; |
| } |
| /** |
| * Dispatch a DOMSubtreeModified event |
| * |
| * \param doc The Document |
| * \param et The EventTarget object |
| * \param success Whether this event's default handler get called |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception __dom_dispatch_subtree_modified_event(dom_document *doc, |
| dom_event_target *et, bool *success) |
| { |
| struct dom_mutation_event *evt; |
| dom_string *type = NULL; |
| dom_exception err; |
| err = _dom_mutation_event_create(doc, &evt); |
| if (err != DOM_NO_ERR) |
| return err; |
| type = dom_string_ref(doc->_memo_domsubtreemodified); |
| err = dom_mutation_event_init(evt, type, true, false, et, NULL, |
| NULL, NULL, DOM_MUTATION_MODIFICATION); |
| dom_string_unref(type); |
| if (err != DOM_NO_ERR) { |
| goto cleanup; |
| } |
| err = dom_event_target_dispatch_event(et, evt, success); |
| cleanup: |
| _dom_mutation_event_destroy(evt); |
| return err; |
| } |
| /** |
| * Dispatch a generic event |
| * |
| * \param doc The Document |
| * \param et The EventTarget object |
| * \param name The name of the event |
| * \param len The length of the name string |
| * \param bubble Whether this event bubbles |
| * \param cancelable Whether this event can be cancelable |
| * \param success Whether this event's default handler get called |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_dispatch_generic_event(dom_document *doc, |
| dom_event_target *et, dom_string *event_name, |
| bool bubble, bool cancelable, bool *success) |
| { |
| struct dom_event *evt; |
| dom_exception err; |
| err = _dom_event_create(doc, &evt); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_event_init(evt, event_name, bubble, cancelable); |
| if (err != DOM_NO_ERR) { |
| goto cleanup; |
| } |
| err = dom_event_target_dispatch_event(et, evt, success); |
| cleanup: |
| _dom_event_destroy(evt); |
| return err; |
| } |
| /contrib/network/netsurf/libdom/src/events/dispatch.h |
|---|
| 0,0 → 1,77 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_events_dispatch_h_ |
| #define dom_internal_events_dispatch_h_ |
| #include <dom/core/document.h> |
| #include <dom/events/event.h> |
| #include <dom/events/mutation_event.h> |
| /* Dispatch a DOMNodeInserted/DOMNodeRemoved event */ |
| dom_exception __dom_dispatch_node_change_event(dom_document *doc, |
| dom_event_target *et, dom_event_target *related, |
| dom_mutation_type change, bool *success); |
| #define _dom_dispatch_node_change_event(doc, et, related, change, success) \ |
| __dom_dispatch_node_change_event((dom_document *) (doc), \ |
| (dom_event_target *) (et), \ |
| (dom_event_target *) (related), \ |
| (dom_mutation_type) (change), \ |
| (bool *) (success)) |
| /* Dispatch a DOMNodeInsertedIntoDocument/DOMNodeRemovedFromDocument event */ |
| dom_exception __dom_dispatch_node_change_document_event(dom_document *doc, |
| dom_event_target *et, dom_mutation_type change, bool *success); |
| #define _dom_dispatch_node_change_document_event(doc, et, change, success) \ |
| __dom_dispatch_node_change_document_event((dom_document *) (doc), \ |
| (dom_event_target *) (et), \ |
| (dom_mutation_type) (change), \ |
| (bool *) (success)) |
| /* Dispatch a DOMCharacterDataModified event */ |
| dom_exception __dom_dispatch_characterdata_modified_event( |
| dom_document *doc, dom_event_target *et, |
| dom_string *prev, dom_string *new, bool *success); |
| #define _dom_dispatch_characterdata_modified_event(doc, et, \ |
| prev, new, success) \ |
| __dom_dispatch_characterdata_modified_event((dom_document *) (doc), \ |
| (dom_event_target *) (et), \ |
| (dom_string *) (prev), \ |
| (dom_string *) (new), \ |
| (bool *) (success)) |
| /* Dispatch a DOMAttrModified event */ |
| dom_exception __dom_dispatch_attr_modified_event(dom_document *doc, |
| dom_event_target *et, dom_string *prev, |
| dom_string *new, dom_event_target *related, |
| dom_string *attr_name, dom_mutation_type change, |
| bool *success); |
| #define _dom_dispatch_attr_modified_event(doc, et, prev, new, \ |
| related, attr_name, change, success) \ |
| __dom_dispatch_attr_modified_event((dom_document *) (doc), \ |
| (dom_event_target *) (et), \ |
| (dom_string *) (prev), \ |
| (dom_string *) (new), \ |
| (dom_event_target *) (related), \ |
| (dom_string *) (attr_name), \ |
| (dom_mutation_type) (change), \ |
| (bool *) (success)) |
| /* Dispatch a DOMSubtreeModified event */ |
| dom_exception __dom_dispatch_subtree_modified_event(dom_document *doc, |
| dom_event_target *et, bool *success); |
| #define _dom_dispatch_subtree_modified_event(doc, et, success) \ |
| __dom_dispatch_subtree_modified_event((dom_document *) (doc), \ |
| (dom_event_target *) (et), \ |
| (bool *) (success)) |
| /* Dispatch a generic event */ |
| dom_exception _dom_dispatch_generic_event(dom_document *doc, |
| dom_event_target *et, dom_string *event_name, |
| bool bubble, bool cancelable, bool *success); |
| #endif |
| /contrib/network/netsurf/libdom/src/events/document_event.c |
|---|
| 0,0 → 1,194 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <string.h> |
| #include <libwapcaplet/libwapcaplet.h> |
| #include "core/string.h" |
| #include "core/node.h" |
| #include "core/document.h" |
| #include "events/document_event.h" |
| #include "events/event.h" |
| #include "events/ui_event.h" |
| #include "events/custom_event.h" |
| #include "events/text_event.h" |
| #include "events/keyboard_event.h" |
| #include "events/mouse_event.h" |
| #include "events/mouse_multi_wheel_event.h" |
| #include "events/mouse_wheel_event.h" |
| #include "events/mutation_event.h" |
| #include "events/mutation_name_event.h" |
| #include "utils/utils.h" |
| static const char *__event_types[] = { |
| "Event", |
| "CustomEvent", |
| "UIEvent", |
| "TextEvent", |
| "KeyboardEvent", |
| "MouseEvent", |
| "MouseMultiWheelEvent", |
| "MouseWheelEvent", |
| "MutationEvent", |
| "MutationNameEvent" |
| }; |
| /** |
| * Initialise this DocumentEvent |
| * |
| * \param doc The document object |
| * \param dei The DocumentEvent internal object |
| * \param actions The default action fetcher, the browser should provide such |
| * a function to Event module. |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_document_event_internal_initialise(struct dom_document *doc, |
| dom_document_event_internal *dei, |
| dom_events_default_action_fetcher actions, |
| void *actions_ctx) |
| { |
| lwc_error err; |
| int i; |
| UNUSED(doc); |
| for (i = 0; i < DOM_EVENT_COUNT; i++) { |
| err = lwc_intern_string(__event_types[i], |
| strlen(__event_types[i]), &dei->event_types[i]); |
| if (err != lwc_error_ok) |
| return _dom_exception_from_lwc_error(err); |
| } |
| dei->actions = actions; |
| dei->actions_ctx = actions_ctx; |
| return DOM_NO_ERR; |
| } |
| /* Finalise this DocumentEvent */ |
| void _dom_document_event_internal_finalise(struct dom_document *doc, |
| dom_document_event_internal *dei) |
| { |
| int i; |
| UNUSED(doc); |
| for (i = 0; i < DOM_EVENT_COUNT; i++) { |
| if (dei->event_types[i] != NULL) |
| lwc_string_unref(dei->event_types[i]); |
| } |
| return; |
| } |
| /*-------------------------------------------------------------------------*/ |
| /* Public API */ |
| /** |
| * Create an Event object |
| * |
| * \param de The DocumentEvent object |
| * \param type The Event type |
| * \param evt The returned Event object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_document_event_create_event(dom_document_event *de, |
| dom_string *type, struct dom_event **evt) |
| { |
| lwc_string *t = NULL; |
| dom_exception err; |
| struct dom_document *doc = de; |
| int i, et = 0; |
| dom_document_event_internal *dei; |
| err = dom_string_intern(type, &t); |
| if (err != DOM_NO_ERR) |
| return err; |
| assert(t != NULL); |
| dei = &de->dei; |
| for (i = 0; i < DOM_EVENT_COUNT; i++) { |
| if (dei->event_types[i] == t) { |
| et = i; |
| break; |
| } |
| } |
| lwc_string_unref(t); |
| switch (et) { |
| case DOM_EVENT: |
| err = _dom_event_create(doc, evt); |
| break; |
| case DOM_CUSTOM_EVENT: |
| err = _dom_custom_event_create(doc, |
| (dom_custom_event **) evt); |
| break; |
| case DOM_UI_EVENT: |
| err = _dom_ui_event_create(doc, (dom_ui_event **) evt); |
| break; |
| case DOM_TEXT_EVENT: |
| err = _dom_text_event_create(doc, |
| (dom_text_event **) evt); |
| break; |
| case DOM_KEYBOARD_EVENT: |
| err = _dom_keyboard_event_create(doc, |
| (dom_keyboard_event **) evt); |
| break; |
| case DOM_MOUSE_EVENT: |
| err = _dom_mouse_event_create(doc, |
| (dom_mouse_event **) evt); |
| break; |
| case DOM_MOUSE_MULTI_WHEEL_EVENT: |
| err = _dom_mouse_multi_wheel_event_create(doc, |
| (dom_mouse_multi_wheel_event **) evt); |
| break; |
| case DOM_MOUSE_WHEEL_EVENT: |
| err = _dom_mouse_wheel_event_create(doc, |
| (dom_mouse_wheel_event **) evt); |
| break; |
| case DOM_MUTATION_EVENT: |
| err = _dom_mutation_event_create(doc, |
| (dom_mutation_event **) evt); |
| break; |
| case DOM_MUTATION_NAME_EVENT: |
| err = _dom_mutation_name_event_create(doc, |
| (dom_mutation_name_event **) evt); |
| break; |
| default: |
| assert("Should never be here" == NULL); |
| } |
| return err; |
| } |
| /** |
| * Tests if the implementation can generate events of a specified type |
| * |
| * \param de The DocumentEvent |
| * \param namespace The namespace of the event |
| * \param type The type of the event |
| * \param can True if we can generate such an event, false otherwise |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * We don't support this API now, so the return value should always |
| * DOM_NO_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_document_event_can_dispatch(dom_document_event *de, |
| dom_string *namespace, dom_string *type, |
| bool *can) |
| { |
| UNUSED(de); |
| UNUSED(namespace); |
| UNUSED(type); |
| UNUSED(can); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/events/document_event.h |
|---|
| 0,0 → 1,64 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_events_document_event_h_ |
| #define dom_internal_events_document_event_h_ |
| #include <dom/events/document_event.h> |
| struct dom_event_listener; |
| struct lwc_string_s; |
| struct dom_document; |
| /** |
| * Type of Events |
| */ |
| typedef enum { |
| DOM_EVENT = 0, |
| DOM_CUSTOM_EVENT, |
| DOM_UI_EVENT, |
| DOM_TEXT_EVENT, |
| DOM_KEYBOARD_EVENT, |
| DOM_MOUSE_EVENT, |
| DOM_MOUSE_MULTI_WHEEL_EVENT, |
| DOM_MOUSE_WHEEL_EVENT, |
| DOM_MUTATION_EVENT, |
| DOM_MUTATION_NAME_EVENT, |
| DOM_EVENT_COUNT |
| } dom_event_type; |
| /** |
| * The DocumentEvent internal class |
| */ |
| struct dom_document_event_internal { |
| dom_events_default_action_fetcher actions; |
| /**< The default action fetecher */ |
| void *actions_ctx; /**< The default action fetcher context */ |
| struct lwc_string_s *event_types[DOM_EVENT_COUNT]; |
| /**< Events type names */ |
| }; |
| typedef struct dom_document_event_internal dom_document_event_internal; |
| /** |
| * Constructor and destructor: Since this object is not intended to be |
| * allocated alone, it should be embedded into the Document object, there |
| * is no constructor and destructor for it. |
| */ |
| /* Initialise this DocumentEvent */ |
| dom_exception _dom_document_event_internal_initialise(struct dom_document *doc, |
| dom_document_event_internal *dei, |
| dom_events_default_action_fetcher actions, |
| void *actions_ctx); |
| /* Finalise this DocumentEvent */ |
| void _dom_document_event_internal_finalise(struct dom_document *doc, |
| dom_document_event_internal *dei); |
| #endif |
| /contrib/network/netsurf/libdom/src/events/event.c |
|---|
| 0,0 → 1,332 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <time.h> |
| #include "events/event.h" |
| #include "core/string.h" |
| #include "core/node.h" |
| #include "core/document.h" |
| #include "utils/utils.h" |
| static void _virtual_dom_event_destroy(dom_event *evt); |
| static struct dom_event_private_vtable _event_vtable = { |
| _virtual_dom_event_destroy |
| }; |
| /* Constructor */ |
| dom_exception _dom_event_create(dom_document *doc, dom_event **evt) |
| { |
| *evt = (dom_event *) malloc(sizeof(dom_event)); |
| if (*evt == NULL) |
| return DOM_NO_MEM_ERR; |
| (*evt)->vtable = &_event_vtable; |
| return _dom_event_initialise(doc, *evt); |
| } |
| /* Destructor */ |
| void _dom_event_destroy(dom_event *evt) |
| { |
| _dom_event_finalise(evt); |
| free(evt); |
| } |
| /* Initialise function */ |
| dom_exception _dom_event_initialise(dom_document *doc, dom_event *evt) |
| { |
| assert(doc != NULL); |
| evt->doc = doc; |
| evt->stop = false; |
| evt->stop_now = false; |
| evt->prevent_default = false; |
| evt->custom = false; |
| evt->type = NULL; |
| evt->namespace = NULL; |
| evt->refcnt = 1; |
| evt->in_dispatch = false; |
| return DOM_NO_ERR; |
| } |
| /* Finalise function */ |
| void _dom_event_finalise(dom_event *evt) |
| { |
| if (evt->type != NULL) |
| dom_string_unref(evt->type); |
| if (evt->namespace != NULL) |
| dom_string_unref(evt->namespace); |
| evt->stop = false; |
| evt->stop_now = false; |
| evt->prevent_default = false; |
| evt->custom = false; |
| evt->type = NULL; |
| evt->namespace = NULL; |
| evt->in_dispatch = false; |
| } |
| /* The virtual destroy function */ |
| void _virtual_dom_event_destroy(dom_event *evt) |
| { |
| _dom_event_destroy(evt); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Claim a reference on this event object |
| * |
| * \param evt The Event object |
| */ |
| void _dom_event_ref(dom_event *evt) |
| { |
| evt->refcnt++; |
| } |
| /** |
| * Release a reference on this event object |
| * |
| * \param evt The Event object |
| */ |
| void _dom_event_unref(dom_event *evt) |
| { |
| if (evt->refcnt > 0) |
| evt->refcnt--; |
| if (evt->refcnt == 0) |
| dom_event_destroy(evt); |
| } |
| /** |
| * Get the event type |
| * |
| * \param evt The event object |
| * \parnm type The returned event type |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_event_get_type(dom_event *evt, dom_string **type) |
| { |
| *type = dom_string_ref(evt->type); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the target node of this event |
| * |
| * \param evt The event object |
| * \param target The target node |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_event_get_target(dom_event *evt, dom_event_target **target) |
| { |
| *target = evt->target; |
| dom_node_ref(*target); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the current target of this event |
| * |
| * \param evt The event object |
| * \param current The current event target node |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_event_get_current_target(dom_event *evt, |
| dom_event_target **current) |
| { |
| *current = evt->current; |
| dom_node_ref(*current); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get whether this event can bubble |
| * |
| * \param evt The Event object |
| * \param bubbles The returned value |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_event_get_bubbles(dom_event *evt, bool *bubbles) |
| { |
| *bubbles = evt->bubble; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get whether this event can be cancelable |
| * |
| * \param evt The Event object |
| * \param cancelable The returned value |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_event_get_cancelable(dom_event *evt, bool *cancelable) |
| { |
| *cancelable = evt->cancelable; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the event's generation timestamp |
| * |
| * \param evt The Event object |
| * \param timestamp The returned value |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_event_get_timestamp(dom_event *evt, unsigned int *timestamp) |
| { |
| *timestamp = evt->timestamp; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Stop propagation of the event |
| * |
| * \param evt The Event object |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_event_stop_propagation(dom_event *evt) |
| { |
| evt->stop = true; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Prevent the default action of this event |
| * |
| * \param evt The Event object |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_event_prevent_default(dom_event *evt) |
| { |
| evt->prevent_default = true; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Initialise the event object |
| * |
| * \param evt The event object |
| * \param type The type of this event |
| * \param bubble Whether this event can bubble |
| * \param cancelable Whether this event is cancelable |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_event_init(dom_event *evt, dom_string *type, |
| bool bubble, bool cancelable) |
| { |
| assert(evt->doc != NULL); |
| evt->type = dom_string_ref(type); |
| evt->bubble = bubble; |
| evt->cancelable = cancelable; |
| evt->timestamp = time(NULL); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the namespace of this event |
| * |
| * \param evt The event object |
| * \param namespace The returned namespace of this event |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_event_get_namespace(dom_event *evt, |
| dom_string **namespace) |
| { |
| *namespace = dom_string_ref(evt->namespace); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Whether this is a custom event |
| * |
| * \param evt The event object |
| * \param custom The returned value |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_event_is_custom(dom_event *evt, bool *custom) |
| { |
| *custom = evt->custom; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Stop the event propagation immediately |
| * |
| * \param evt The event object |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_event_stop_immediate_propagation(dom_event *evt) |
| { |
| evt->stop_now = true; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Whether the default action is prevented |
| * |
| * \param evt The event object |
| * \param prevented The returned value |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_event_is_default_prevented(dom_event *evt, bool *prevented) |
| { |
| *prevented = evt->prevent_default; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Initialise the event with namespace |
| * |
| * \param evt The event object |
| * \param namespace The namespace of this event |
| * \param type The event type |
| * \param bubble Whether this event has a bubble phase |
| * \param cancelable Whether this event is cancelable |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_event_init_ns(dom_event *evt, dom_string *namespace, |
| dom_string *type, bool bubble, bool cancelable) |
| { |
| assert(evt->doc != NULL); |
| evt->type = dom_string_ref(type); |
| evt->namespace = dom_string_ref(namespace); |
| evt->bubble = bubble; |
| evt->cancelable = cancelable; |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/events/event.h |
|---|
| 0,0 → 1,76 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_events_event_h_ |
| #define dom_internal_events_event_h_ |
| #include <inttypes.h> |
| #include <dom/core/document.h> |
| #include <dom/events/event_target.h> |
| #include <dom/events/event.h> |
| #include "utils/list.h" |
| /* The private virtual table */ |
| struct dom_event_private_vtable { |
| void (*destroy)(dom_event *evt); |
| }; |
| /** |
| * The Event Object |
| */ |
| struct dom_event { |
| dom_string *type; /**< The type of the event */ |
| dom_event_target *target; /**< The event target */ |
| dom_event_target *current; /**< The current event target */ |
| dom_event_flow_phase phase; /**< The event phase */ |
| bool bubble; /**< Whether this event is a bubbling event */ |
| bool cancelable; /**< Whether this event is cancelable */ |
| unsigned int timestamp; |
| /**< The timestamp this event is created */ |
| dom_string *namespace; /**< The namespace of this event */ |
| dom_document *doc; |
| /**< The document which created this event */ |
| bool stop; /**< Whether stopPropagation is called */ |
| bool stop_now; /**< Whether stopImmediatePropagation is called */ |
| bool prevent_default; |
| /**< Whether the default action is prevented */ |
| bool custom; /**< Whether this is a custom event */ |
| uint32_t refcnt; /**< The reference count of this object */ |
| struct dom_event_private_vtable *vtable; |
| /**< The private virtual function table of Event */ |
| bool in_dispatch; /**< Whether this event is in dispatch */ |
| }; |
| /* Constructor */ |
| dom_exception _dom_event_create(dom_document *doc, dom_event **evt); |
| /* Destructor */ |
| void _dom_event_destroy(dom_event *evt); |
| /* Initialise function */ |
| dom_exception _dom_event_initialise(dom_document *doc, dom_event *evt); |
| /* Finalise function */ |
| void _dom_event_finalise(dom_event *evt); |
| static inline void dom_event_destroy(dom_event *evt) |
| { |
| evt->vtable->destroy(evt); |
| } |
| #define dom_event_destroy(e) dom_event_destroy((dom_event *) (e)) |
| #endif |
| /contrib/network/netsurf/libdom/src/events/event_listener.c |
|---|
| 0,0 → 1,62 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "events/event_listener.h" |
| #include "core/document.h" |
| /** |
| * Create an EventListener |
| * |
| * \param doc The document object |
| * \param handler The event function |
| * \param pw The private data |
| * \param listener The returned EventListener |
| * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion. |
| */ |
| dom_exception dom_event_listener_create(struct dom_document *doc, |
| handle_event handler, void *pw, dom_event_listener **listener) |
| { |
| dom_event_listener *ret = malloc(sizeof(dom_event_listener)); |
| if (ret == NULL) |
| return DOM_NO_MEM_ERR; |
| ret->handler = handler; |
| ret->pw = pw; |
| ret->refcnt = 1; |
| ret->doc = doc; |
| *listener = ret; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Claim a new reference on the listener object |
| * |
| * \param listener The EventListener object |
| */ |
| void dom_event_listener_ref(dom_event_listener *listener) |
| { |
| listener->refcnt++; |
| } |
| /** |
| * Release a reference on the listener object |
| * |
| * \param listener The EventListener object |
| */ |
| void dom_event_listener_unref(dom_event_listener *listener) |
| { |
| if (listener->refcnt > 0) |
| listener->refcnt--; |
| if (listener->refcnt == 0) |
| free(listener); |
| } |
| /contrib/network/netsurf/libdom/src/events/event_listener.h |
|---|
| 0,0 → 1,28 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_events_event_listener_h_ |
| #define dom_internal_events_event_listener_h_ |
| #include <dom/events/event_listener.h> |
| #include "utils/list.h" |
| /** |
| * The EventListener class |
| */ |
| struct dom_event_listener { |
| handle_event handler; /**< The event handler function */ |
| void *pw; /**< The private data of this listener */ |
| unsigned int refcnt; /**< The reference count of this listener */ |
| struct dom_document *doc; |
| /**< The document which create this listener */ |
| }; |
| #endif |
| /contrib/network/netsurf/libdom/src/events/event_target.c |
|---|
| 0,0 → 1,231 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include "events/event.h" |
| #include "events/event_listener.h" |
| #include "events/event_target.h" |
| #include "core/document.h" |
| #include "core/node.h" |
| #include "core/string.h" |
| #include "utils/utils.h" |
| #include "utils/validate.h" |
| static void event_target_destroy_listeners(struct listener_entry *list) |
| { |
| struct listener_entry *next = NULL; |
| for (; list != next; list = next) { |
| next = (struct listener_entry *) list->list.next; |
| list_del(&list->list); |
| dom_event_listener_unref(list->listener); |
| dom_string_unref(list->type); |
| free(list); |
| } |
| } |
| /* Initialise this EventTarget */ |
| dom_exception _dom_event_target_internal_initialise( |
| dom_event_target_internal *eti) |
| { |
| eti->listeners = NULL; |
| return DOM_NO_ERR; |
| } |
| /* Finalise this EventTarget */ |
| void _dom_event_target_internal_finalise(dom_event_target_internal *eti) |
| { |
| if (eti->listeners != NULL) |
| event_target_destroy_listeners(eti->listeners); |
| } |
| /*-------------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Add an EventListener to the EventTarget |
| * |
| * \param et The EventTarget object |
| * \param type The event type which this event listener listens for |
| * \param listener The event listener object |
| * \param capture Whether add this listener in the capturing phase |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_event_target_add_event_listener( |
| dom_event_target_internal *eti, |
| dom_string *type, struct dom_event_listener *listener, |
| bool capture) |
| { |
| struct listener_entry *le = NULL; |
| le = malloc(sizeof(struct listener_entry)); |
| if (le == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Initialise the listener_entry */ |
| list_init(&le->list); |
| le->type = dom_string_ref(type); |
| le->listener = listener; |
| dom_event_listener_ref(listener); |
| le->capture = capture; |
| if (eti->listeners == NULL) { |
| eti->listeners = le; |
| } else { |
| list_append(&eti->listeners->list, &le->list); |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Remove an EventListener from the EventTarget |
| * |
| * \param et The EventTarget object |
| * \param type The event type this listener is registered for |
| * \param listener The listener object |
| * \param capture Whether the listener is registered at the capturing phase |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_event_target_remove_event_listener( |
| dom_event_target_internal *eti, |
| dom_string *type, struct dom_event_listener *listener, |
| bool capture) |
| { |
| if (eti->listeners != NULL) { |
| struct listener_entry *le = eti->listeners; |
| do { |
| if (dom_string_isequal(le->type, type) && |
| le->listener == listener && |
| le->capture == capture) { |
| list_del(&le->list); |
| dom_event_listener_unref(le->listener); |
| dom_string_unref(le->type); |
| free(le); |
| break; |
| } |
| le = (struct listener_entry *) le->list.next; |
| } while (le != eti->listeners); |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Add an EventListener |
| * |
| * \param et The EventTarget object |
| * \param namespace The namespace of this listener |
| * \param type The event type which this event listener listens for |
| * \param listener The event listener object |
| * \param capture Whether add this listener in the capturing phase |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * We don't support this API now, so it always return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_event_target_add_event_listener_ns( |
| dom_event_target_internal *eti, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, bool capture) |
| { |
| UNUSED(eti); |
| UNUSED(namespace); |
| UNUSED(type); |
| UNUSED(listener); |
| UNUSED(capture); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Remove an EventListener |
| * |
| * \param et The EventTarget object |
| * \param namespace The namespace of this listener |
| * \param type The event type which this event listener listens for |
| * \param listener The event listener object |
| * \param capture Whether add this listener in the capturing phase |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * We don't support this API now, so it always return DOM_NOT_SUPPORTED_ERR. |
| */ |
| dom_exception _dom_event_target_remove_event_listener_ns( |
| dom_event_target_internal *eti, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, bool capture) |
| { |
| UNUSED(eti); |
| UNUSED(namespace); |
| UNUSED(type); |
| UNUSED(listener); |
| UNUSED(capture); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /*-------------------------------------------------------------------------*/ |
| /** |
| * Dispatch an event on certain EventTarget |
| * |
| * \param et The EventTarget object |
| * \param eti Internal EventTarget object |
| * \param evt The event object |
| * \param success Indicates whether any of the listeners which handled the |
| * event called Event.preventDefault(). If |
| * Event.preventDefault() was called the returned value is |
| * false, else it is true. |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_event_target_dispatch(dom_event_target *et, |
| dom_event_target_internal *eti, |
| struct dom_event *evt, dom_event_flow_phase phase, |
| bool *success) |
| { |
| if (eti->listeners != NULL) { |
| struct listener_entry *le = eti->listeners; |
| evt->current = et; |
| do { |
| if (dom_string_isequal(le->type, evt->type)) { |
| assert(le->listener->handler != NULL); |
| if ((le->capture && |
| phase == DOM_CAPTURING_PHASE) || |
| (le->capture == false && |
| phase == DOM_BUBBLING_PHASE) || |
| (evt->target == evt->current && |
| phase == DOM_AT_TARGET)) { |
| le->listener->handler(evt, |
| le->listener->pw); |
| /* If the handler called |
| * stopImmediatePropagation, we should |
| * break */ |
| if (evt->stop_now == true) |
| break; |
| } |
| } |
| le = (struct listener_entry *) le->list.next; |
| } while (le != eti->listeners); |
| } |
| if (evt->prevent_default == true) |
| *success = false; |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/events/event_target.h |
|---|
| 0,0 → 1,87 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_events_event_target_h_ |
| #define dom_internal_events_event_target_h_ |
| #include <dom/core/document.h> |
| #include <dom/events/event.h> |
| #include <dom/events/mutation_event.h> |
| #include <dom/events/event_target.h> |
| #include <dom/events/event_listener.h> |
| #include "events/dispatch.h" |
| #include "utils/list.h" |
| /** |
| * Listener Entry |
| */ |
| struct listener_entry { |
| struct list_entry list; |
| /**< The listener list registered at the same |
| * EventTarget */ |
| dom_string *type; /**< Event type */ |
| dom_event_listener *listener; /**< The EventListener */ |
| bool capture; /**< Whether this listener is in capture phase */ |
| }; |
| /** |
| * EventTarget internal class |
| */ |
| struct dom_event_target_internal { |
| struct listener_entry *listeners; |
| /**< The listeners of this EventTarget. */ |
| }; |
| typedef struct dom_event_target_internal dom_event_target_internal; |
| /* Entry for a EventTarget, used to record the bubbling list */ |
| typedef struct dom_event_target_entry { |
| struct list_entry entry; /**< The list entry */ |
| dom_event_target *et; /**< The node */ |
| } dom_event_target_entry; |
| /** |
| * Constructor and destructor: Since this object is not intended to be |
| * allocated alone, it should be embedded into the Node object, there is |
| * no constructor and destructor for it. |
| */ |
| /* Initialise this EventTarget */ |
| dom_exception _dom_event_target_internal_initialise( |
| dom_event_target_internal *eti); |
| /* Finalise this EventTarget */ |
| void _dom_event_target_internal_finalise(dom_event_target_internal *eti); |
| dom_exception _dom_event_target_add_event_listener( |
| dom_event_target_internal *eti, |
| dom_string *type, struct dom_event_listener *listener, |
| bool capture); |
| dom_exception _dom_event_target_remove_event_listener( |
| dom_event_target_internal *eti, |
| dom_string *type, struct dom_event_listener *listener, |
| bool capture); |
| dom_exception _dom_event_target_add_event_listener_ns( |
| dom_event_target_internal *eti, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, bool capture); |
| dom_exception _dom_event_target_remove_event_listener_ns( |
| dom_event_target_internal *eti, |
| dom_string *namespace, dom_string *type, |
| struct dom_event_listener *listener, bool capture); |
| dom_exception _dom_event_target_dispatch(dom_event_target *et, |
| dom_event_target_internal *eti, |
| struct dom_event *evt, dom_event_flow_phase phase, |
| bool *success); |
| #endif |
| /contrib/network/netsurf/libdom/src/events/keyboard_event.c |
|---|
| 0,0 → 1,359 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include <string.h> |
| #include "events/keyboard_event.h" |
| #include "core/document.h" |
| #include "utils/utils.h" |
| static void _virtual_dom_keyboard_event_destroy(struct dom_event *evt); |
| static struct dom_event_private_vtable _event_vtable = { |
| _virtual_dom_keyboard_event_destroy |
| }; |
| /* Constructor */ |
| dom_exception _dom_keyboard_event_create(struct dom_document *doc, |
| struct dom_keyboard_event **evt) |
| { |
| *evt = malloc(sizeof(dom_keyboard_event)); |
| if (*evt == NULL) |
| return DOM_NO_MEM_ERR; |
| ((struct dom_event *) *evt)->vtable = &_event_vtable; |
| return _dom_keyboard_event_initialise(doc, *evt); |
| } |
| /* Destructor */ |
| void _dom_keyboard_event_destroy(struct dom_keyboard_event *evt) |
| { |
| _dom_keyboard_event_finalise(evt); |
| free(evt); |
| } |
| /* Initialise function */ |
| dom_exception _dom_keyboard_event_initialise(struct dom_document *doc, |
| struct dom_keyboard_event *evt) |
| { |
| evt->key_ident = NULL; |
| evt->modifier_state = 0; |
| return _dom_ui_event_initialise(doc, &evt->base); |
| } |
| /* Finalise function */ |
| void _dom_keyboard_event_finalise(struct dom_keyboard_event *evt) |
| { |
| _dom_ui_event_finalise(&evt->base); |
| } |
| /* The virtual destroy function */ |
| void _virtual_dom_keyboard_event_destroy(struct dom_event *evt) |
| { |
| _dom_keyboard_event_destroy((dom_keyboard_event *) evt); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Get the key identifier |
| * |
| * \param evt The Event object |
| * \param ident The returned key identifier |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_keyboard_event_get_key_identifier(dom_keyboard_event *evt, |
| dom_string **ident) |
| { |
| *ident = evt->key_ident; |
| dom_string_ref(*ident); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the key location |
| * |
| * \param evt The Event object |
| * \param loc The returned key location |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_keyboard_event_get_key_location(dom_keyboard_event *evt, |
| dom_key_location *loc) |
| { |
| *loc = evt->key_loc; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the ctrl key state |
| * |
| * \param evt The Event object |
| * \param key Whether the Control key is pressed down |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_keyboard_event_get_ctrl_key(dom_keyboard_event *evt, |
| bool *key) |
| { |
| *key = ((evt->modifier_state & DOM_MOD_CTRL) != 0); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the shift key state |
| * |
| * \param evt The Event object |
| * \param key Whether the Shift key is pressed down |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_keyboard_event_get_shift_key(dom_keyboard_event *evt, |
| bool *key) |
| { |
| *key = ((evt->modifier_state & DOM_MOD_SHIFT) != 0); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the alt key state |
| * |
| * \param evt The Event object |
| * \param key Whether the Alt key is pressed down |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_keyboard_event_get_alt_key(dom_keyboard_event *evt, |
| bool *key) |
| { |
| *key = ((evt->modifier_state & DOM_MOD_ALT) != 0); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the meta key state |
| * |
| * \param evt The Event object |
| * \param key Whether the Meta key is pressed down |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_keyboard_event_get_meta_key(dom_keyboard_event *evt, |
| bool *key) |
| { |
| *key = ((evt->modifier_state & DOM_MOD_META) != 0); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Query the state of a modifier using a key identifier |
| * |
| * \param evt The event object |
| * \param ml The modifier identifier, such as "Alt", "Control", "Meta", |
| * "AltGraph", "CapsLock", "NumLock", "Scroll", "Shift". |
| * \param state Whether the modifier key is pressed |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * @note: If an application wishes to distinguish between right and left |
| * modifiers, this information could be deduced using keyboard events and |
| * KeyboardEvent.keyLocation. |
| */ |
| dom_exception _dom_keyboard_event_get_modifier_state(dom_keyboard_event *evt, |
| dom_string *m, bool *state) |
| { |
| const char *data; |
| size_t len; |
| if (m == NULL) { |
| *state = false; |
| return DOM_NO_ERR; |
| } |
| data = dom_string_data(m); |
| len = dom_string_byte_length(m); |
| if (len == SLEN("AltGraph") && strncmp(data, "AltGraph", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_ALT_GRAPH) != 0); |
| } else if (len == SLEN("Alt") && strncmp(data, "Alt", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_ALT) != 0); |
| } else if (len == SLEN("CapsLock") && |
| strncmp(data, "CapsLock", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_CAPS_LOCK) != 0); |
| } else if (len == SLEN("Control") && |
| strncmp(data, "Control", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_CTRL) != 0); |
| } else if (len == SLEN("Meta") && strncmp(data, "Meta", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_META) != 0); |
| } else if (len == SLEN("NumLock") && |
| strncmp(data, "NumLock", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_NUM_LOCK) != 0); |
| } else if (len == SLEN("Scroll") && |
| strncmp(data, "Scroll", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_SCROLL) != 0); |
| } else if (len == SLEN("Shift") && strncmp(data, "Shift", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_SHIFT) != 0); |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Initialise the keyboard event |
| * |
| * \param evt The Event object |
| * \param type The event's type |
| * \param bubble Whether this is a bubbling event |
| * \param cancelable Whether this is a cancelable event |
| * \param view The AbstractView associated with this event |
| * \param key_indent The key identifier of pressed key |
| * \param key_loc The key location of the preesed key |
| * \param modifier_list A string of modifier key identifiers, separated with |
| * space |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_keyboard_event_init(dom_keyboard_event *evt, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_abstract_view *view, dom_string *key_ident, |
| dom_key_location key_loc, dom_string *modifier_list) |
| { |
| dom_exception err; |
| evt->key_ident = key_ident; |
| dom_string_ref(evt->key_ident); |
| evt->key_loc = key_loc; |
| err = _dom_parse_modifier_list(modifier_list, &evt->modifier_state); |
| if (err != DOM_NO_ERR) |
| return err; |
| return _dom_ui_event_init(&evt->base, type, bubble, cancelable, |
| view, 0); |
| } |
| /** |
| * Initialise the keyboard event with namespace |
| * |
| * \param evt The Event object |
| * \param namespace The namespace of this event |
| * \param type The event's type |
| * \param bubble Whether this is a bubbling event |
| * \param cancelable Whether this is a cancelable event |
| * \param view The AbstractView associated with this event |
| * \param key_indent The key identifier of pressed key |
| * \param key_loc The key location of the preesed key |
| * \param modifier_list A string of modifier key identifiers, separated with |
| * space |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_keyboard_event_init_ns(dom_keyboard_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, struct dom_abstract_view *view, |
| dom_string *key_ident, dom_key_location key_loc, |
| dom_string *modifier_list) |
| { |
| dom_exception err; |
| evt->key_ident = key_ident; |
| dom_string_ref(evt->key_ident); |
| evt->key_loc = key_loc; |
| err = _dom_parse_modifier_list(modifier_list, &evt->modifier_state); |
| if (err != DOM_NO_ERR) |
| return err; |
| return _dom_ui_event_init_ns(&evt->base, namespace, type, bubble, |
| cancelable, view, 0); |
| } |
| /*-------------------------------------------------------------------------*/ |
| /** |
| * Parse the modifier list string to corresponding bool variable state |
| * |
| * \param modifier_list The modifier list string |
| * \param modifier_state The returned state |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_parse_modifier_list(dom_string *modifier_list, |
| uint32_t *modifier_state) |
| { |
| const char *data; |
| const char *m; |
| size_t len = 0; |
| *modifier_state = 0; |
| if (modifier_list == NULL) |
| return DOM_NO_ERR; |
| data = dom_string_data(modifier_list); |
| m = data; |
| while (true) { |
| /* If we reach a space or end of the string, we should parse |
| * the new token. */ |
| if (*data == ' ' || *data == '\0') { |
| if (len == SLEN("AltGraph") && |
| strncmp(m, "AltGraph", len) == 0) { |
| *modifier_state = *modifier_state | |
| DOM_MOD_ALT_GRAPH; |
| } else if (len == SLEN("Alt") && |
| strncmp(m, "Alt", len) == 0) { |
| *modifier_state = *modifier_state | |
| DOM_MOD_ALT; |
| } else if (len == SLEN("CapsLock") && |
| strncmp(m, "CapsLock", len) == 0) { |
| *modifier_state = *modifier_state | |
| DOM_MOD_CAPS_LOCK; |
| } else if (len == SLEN("Control") && |
| strncmp(m, "Control", len) == 0) { |
| *modifier_state = *modifier_state | |
| DOM_MOD_CTRL; |
| } else if (len == SLEN("Meta") && |
| strncmp(m, "Meta", len) == 0) { |
| *modifier_state = *modifier_state | |
| DOM_MOD_META; |
| } else if (len == SLEN("NumLock") && |
| strncmp(m, "NumLock", len) == 0) { |
| *modifier_state = *modifier_state | |
| DOM_MOD_NUM_LOCK; |
| } else if (len == SLEN("Scroll") && |
| strncmp(m, "Scroll", len) == 0) { |
| *modifier_state = *modifier_state | |
| DOM_MOD_SCROLL; |
| } else if (len == SLEN("Shift") && |
| strncmp(m, "Shift", len) == 0) { |
| *modifier_state = *modifier_state | |
| DOM_MOD_SHIFT; |
| } |
| while (*data == ' ') { |
| data++; |
| } |
| /* Finished parsing and break */ |
| if (*data == '\0') |
| break; |
| m = data; |
| len = 0; |
| } |
| data++; |
| len++; |
| } |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/events/keyboard_event.h |
|---|
| 0,0 → 1,53 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_interntal_events_keyboard_event_h_ |
| #define dom_interntal_events_keyboard_event_h_ |
| #include <dom/events/keyboard_event.h> |
| #include "events/ui_event.h" |
| /** |
| * The keyboard event |
| */ |
| struct dom_keyboard_event { |
| struct dom_ui_event base; /**< The base class */ |
| dom_string *key_ident; /**< The identifier of the key in this |
| * event, please refer: |
| * http://www.w3.org/TR/DOM-Level-3-Events/keyset.html#KeySet-Set |
| * for detail |
| */ |
| dom_key_location key_loc; /**< Indicate the location of the key on |
| * the keyboard |
| */ |
| uint32_t modifier_state; /**< The modifier keys state */ |
| }; |
| /* Constructor */ |
| dom_exception _dom_keyboard_event_create(struct dom_document *doc, |
| struct dom_keyboard_event **evt); |
| /* Destructor */ |
| void _dom_keyboard_event_destroy(struct dom_keyboard_event *evt); |
| /* Initialise function */ |
| dom_exception _dom_keyboard_event_initialise(struct dom_document *doc, |
| struct dom_keyboard_event *evt); |
| /* Finalise function */ |
| void _dom_keyboard_event_finalise(struct dom_keyboard_event *evt); |
| /* Parse the modifier list string to corresponding bool variable state */ |
| dom_exception _dom_parse_modifier_list(dom_string *modifier_list, |
| uint32_t *modifier_state); |
| #endif |
| /contrib/network/netsurf/libdom/src/events/mouse_event.c |
|---|
| 0,0 → 1,369 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include <string.h> |
| #include "events/mouse_event.h" |
| #include "core/document.h" |
| #include "utils/utils.h" |
| static void _virtual_dom_mouse_event_destroy(struct dom_event *evt); |
| static struct dom_event_private_vtable _event_vtable = { |
| _virtual_dom_mouse_event_destroy |
| }; |
| /* Constructor */ |
| dom_exception _dom_mouse_event_create(struct dom_document *doc, |
| struct dom_mouse_event **evt) |
| { |
| *evt = malloc(sizeof(dom_mouse_event)); |
| if (*evt == NULL) |
| return DOM_NO_MEM_ERR; |
| ((struct dom_event *) *evt)->vtable = &_event_vtable; |
| return _dom_mouse_event_initialise(doc, *evt); |
| } |
| /* Destructor */ |
| void _dom_mouse_event_destroy(struct dom_mouse_event *evt) |
| { |
| _dom_mouse_event_finalise((dom_ui_event *) evt); |
| free(evt); |
| } |
| /* Initialise function */ |
| dom_exception _dom_mouse_event_initialise(struct dom_document *doc, |
| struct dom_mouse_event *evt) |
| { |
| evt->modifier_state = 0; |
| return _dom_ui_event_initialise(doc, (dom_ui_event *) evt); |
| } |
| /* The virtual destroy function */ |
| void _virtual_dom_mouse_event_destroy(struct dom_event *evt) |
| { |
| _dom_mouse_event_destroy((dom_mouse_event *) evt); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Get screenX |
| * |
| * \param evt The Event object |
| * \param x The returned screenX |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_event_get_screen_x(dom_mouse_event *evt, |
| int32_t *x) |
| { |
| *x = evt->sx; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get screenY |
| * |
| * \param evt The Event object |
| * \param y The returned screenY |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_event_get_screen_y(dom_mouse_event *evt, |
| int32_t *y) |
| { |
| *y = evt->sy; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get clientX |
| * |
| * \param evt The Event object |
| * \param x The returned clientX |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_event_get_client_x(dom_mouse_event *evt, |
| int32_t *x) |
| { |
| *x = evt->cx; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get clientY |
| * |
| * \param evt The Event object |
| * \param y The returned clientY |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_event_get_client_y(dom_mouse_event *evt, |
| int32_t *y) |
| { |
| *y = evt->cy; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the ctrl key state |
| * |
| * \param evt The Event object |
| * \param key Whether the Control key is pressed down |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_event_get_ctrl_key(dom_mouse_event *evt, |
| bool *key) |
| { |
| *key = ((evt->modifier_state & DOM_MOD_CTRL) != 0); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the shift key state |
| * |
| * \param evt The Event object |
| * \param key Whether the Shift key is pressed down |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_event_get_shift_key(dom_mouse_event *evt, |
| bool *key) |
| { |
| *key = ((evt->modifier_state & DOM_MOD_SHIFT) != 0); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the alt key state |
| * |
| * \param evt The Event object |
| * \param key Whether the Alt key is pressed down |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_event_get_alt_key(dom_mouse_event *evt, |
| bool *key) |
| { |
| *key = ((evt->modifier_state & DOM_MOD_ALT) != 0); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the meta key state |
| * |
| * \param evt The Event object |
| * \param key Whether the Meta key is pressed down |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_event_get_meta_key(dom_mouse_event *evt, |
| bool *key) |
| { |
| *key = ((evt->modifier_state & DOM_MOD_META) != 0); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the button which get pressed |
| * |
| * \param evt The Event object |
| * \param button The pressed mouse button |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_event_get_button(dom_mouse_event *evt, |
| unsigned short *button) |
| { |
| *button = evt->button; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the related target |
| * |
| * \param evt The Event object |
| * \param et The related EventTarget |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_event_get_related_target(dom_mouse_event *evt, |
| dom_event_target **et) |
| { |
| *et = evt->related_target; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Query the state of a modifier using a key identifier |
| * |
| * \param evt The event object |
| * \param ml The modifier identifier, such as "Alt", "Control", "Meta", |
| * "AltGraph", "CapsLock", "NumLock", "Scroll", "Shift". |
| * \param state Whether the modifier key is pressed |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * @note: If an application wishes to distinguish between right and left |
| * modifiers, this information could be deduced using keyboard events and |
| * KeyboardEvent.keyLocation. |
| */ |
| dom_exception _dom_mouse_event_get_modifier_state(dom_mouse_event *evt, |
| dom_string *m, bool *state) |
| { |
| const char *data; |
| size_t len; |
| if (m == NULL) { |
| *state = false; |
| return DOM_NO_ERR; |
| } |
| data = dom_string_data(m); |
| len = dom_string_byte_length(m); |
| if (len == SLEN("AltGraph") && strncmp(data, "AltGraph", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_ALT_GRAPH) != 0); |
| } else if (len == SLEN("Alt") && strncmp(data, "Alt", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_ALT) != 0); |
| } else if (len == SLEN("CapsLock") && |
| strncmp(data, "CapsLock", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_CAPS_LOCK) != 0); |
| } else if (len == SLEN("Control") && |
| strncmp(data, "Control", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_CTRL) != 0); |
| } else if (len == SLEN("Meta") && strncmp(data, "Meta", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_META) != 0); |
| } else if (len == SLEN("NumLock") && |
| strncmp(data, "NumLock", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_NUM_LOCK) != 0); |
| } else if (len == SLEN("Scroll") && |
| strncmp(data, "Scroll", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_SCROLL) != 0); |
| } else if (len == SLEN("Shift") && strncmp(data, "Shift", len) == 0) { |
| *state = ((evt->modifier_state & DOM_MOD_SHIFT) != 0); |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Initialise this mouse event |
| * |
| * \param evt The Event object |
| * \param type The event's type |
| * \param bubble Whether this is a bubbling event |
| * \param cancelable Whether this is a cancelable event |
| * \param view The AbstractView associated with this event |
| * \param detail The detail information of this mouse event |
| * \param screen_x The x position of the mouse pointer in screen |
| * \param screen_y The y position of the mouse pointer in screen |
| * \param client_x The x position of the mouse pointer in client window |
| * \param client_y The y position of the mouse pointer in client window |
| * \param alt The state of Alt key, true for pressed, false otherwise |
| * \param shift The state of Shift key, true for pressed, false otherwise |
| * \param mata The state of Meta key, true for pressed, false otherwise |
| * \param button The mouse button pressed |
| * \param et The related target of this event, may be NULL |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_mouse_event_init(dom_mouse_event *evt, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_abstract_view *view, int32_t detail, int32_t screen_x, |
| int32_t screen_y, int32_t client_x, int32_t client_y, bool ctrl, |
| bool alt, bool shift, bool meta, unsigned short button, |
| dom_event_target *et) |
| { |
| evt->sx = screen_x; |
| evt->sy = screen_y; |
| evt->cx = client_x; |
| evt->cy = client_y; |
| evt->modifier_state = 0; |
| if (ctrl == true) { |
| evt->modifier_state = evt->modifier_state | DOM_MOD_CTRL; |
| } |
| if (alt == true) { |
| evt->modifier_state = evt->modifier_state | DOM_MOD_ALT; |
| } |
| if (shift == true) { |
| evt->modifier_state = evt->modifier_state | DOM_MOD_SHIFT; |
| } |
| if (meta == true) { |
| evt->modifier_state = evt->modifier_state | DOM_MOD_META; |
| } |
| evt->button = button; |
| evt->related_target = et; |
| return _dom_ui_event_init(&evt->base, type, bubble, cancelable, view, |
| detail); |
| } |
| /** |
| * Initialise the event with namespace |
| * |
| * \param evt The Event object |
| * \param namespace The namespace of this event |
| * \param type The event's type |
| * \param bubble Whether this is a bubbling event |
| * \param cancelable Whether this is a cancelable event |
| * \param view The AbstractView associated with this event |
| * \param detail The detail information of this mouse event |
| * \param screen_x The x position of the mouse pointer in screen |
| * \param screen_y The y position of the mouse pointer in screen |
| * \param client_x The x position of the mouse pointer in client window |
| * \param client_y The y position of the mouse pointer in client window |
| * \param alt The state of Alt key, true for pressed, false otherwise |
| * \param shift The state of Shift key, true for pressed, false otherwise |
| * \param mata The state of Meta key, true for pressed, false otherwise |
| * \param button The mouse button pressed |
| * \param et The related target of this event, may be NULL |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_mouse_event_init_ns(dom_mouse_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, struct dom_abstract_view *view, |
| int32_t detail, int32_t screen_x, int32_t screen_y, int32_t client_x, |
| int32_t client_y, bool ctrl, bool alt, bool shift, bool meta, |
| unsigned short button, dom_event_target *et) |
| { |
| evt->sx = screen_x; |
| evt->sy = screen_y; |
| evt->cx = client_x; |
| evt->cy = client_y; |
| evt->modifier_state = 0; |
| if (ctrl == true) { |
| evt->modifier_state = evt->modifier_state | DOM_MOD_CTRL; |
| } |
| if (alt == true) { |
| evt->modifier_state = evt->modifier_state | DOM_MOD_ALT; |
| } |
| if (shift == true) { |
| evt->modifier_state = evt->modifier_state | DOM_MOD_SHIFT; |
| } |
| if (meta == true) { |
| evt->modifier_state = evt->modifier_state | DOM_MOD_META; |
| } |
| evt->button = button; |
| evt->related_target = et; |
| return _dom_ui_event_init_ns(&evt->base, namespace, type, bubble, |
| cancelable, view, detail); |
| } |
| /contrib/network/netsurf/libdom/src/events/mouse_event.h |
|---|
| 0,0 → 1,48 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_interntal_events_mouse_event_h_ |
| #define dom_interntal_events_mouse_event_h_ |
| #include <dom/events/mouse_event.h> |
| #include "events/ui_event.h" |
| /** |
| * The mouse event |
| */ |
| struct dom_mouse_event { |
| struct dom_ui_event base; /**< Base class */ |
| int32_t sx; /**< ScreenX */ |
| int32_t sy; /**< ScreenY */ |
| int32_t cx; /**< ClientX */ |
| int32_t cy; /**< ClientY */ |
| uint32_t modifier_state; /**< The modifier keys state */ |
| unsigned short button; /**< Which button is clicked */ |
| dom_event_target *related_target; /**< The related target */ |
| }; |
| /* Constructor */ |
| dom_exception _dom_mouse_event_create(struct dom_document *doc, |
| struct dom_mouse_event **evt); |
| /* Destructor */ |
| void _dom_mouse_event_destroy(struct dom_mouse_event *evt); |
| /* Initialise function */ |
| dom_exception _dom_mouse_event_initialise(struct dom_document *doc, |
| struct dom_mouse_event *evt); |
| /* Finalise function */ |
| #define _dom_mouse_event_finalise _dom_ui_event_finalise |
| #endif |
| /contrib/network/netsurf/libdom/src/events/mouse_multi_wheel_event.c |
|---|
| 0,0 → 1,153 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "events/mouse_multi_wheel_event.h" |
| #include "events/keyboard_event.h" |
| #include "core/document.h" |
| #include "utils/utils.h" |
| static void _virtual_dom_mouse_multi_wheel_event_destroy( |
| struct dom_event *evt); |
| static struct dom_event_private_vtable _event_vtable = { |
| _virtual_dom_mouse_multi_wheel_event_destroy |
| }; |
| /* Constructor */ |
| dom_exception _dom_mouse_multi_wheel_event_create(struct dom_document *doc, |
| struct dom_mouse_multi_wheel_event **evt) |
| { |
| *evt = malloc(sizeof(dom_mouse_multi_wheel_event)); |
| if (*evt == NULL) |
| return DOM_NO_MEM_ERR; |
| ((struct dom_event *) *evt)->vtable = &_event_vtable; |
| return _dom_mouse_multi_wheel_event_initialise(doc, *evt); |
| } |
| /* Destructor */ |
| void _dom_mouse_multi_wheel_event_destroy( |
| struct dom_mouse_multi_wheel_event *evt) |
| { |
| _dom_mouse_multi_wheel_event_finalise((dom_ui_event *) evt); |
| free(evt); |
| } |
| /* Initialise function */ |
| dom_exception _dom_mouse_multi_wheel_event_initialise(struct dom_document *doc, |
| struct dom_mouse_multi_wheel_event *evt) |
| { |
| return _dom_mouse_event_initialise(doc, (dom_mouse_event *) evt); |
| } |
| /* The virtual destroy function */ |
| void _virtual_dom_mouse_multi_wheel_event_destroy(struct dom_event *evt) |
| { |
| _dom_mouse_multi_wheel_event_destroy( |
| (dom_mouse_multi_wheel_event *) evt); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Get wheelDeltaX |
| * |
| * \param evt The Event object |
| * \param x The returned wheelDeltaX |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_multi_wheel_event_get_wheel_delta_x( |
| dom_mouse_multi_wheel_event *evt, int32_t *x) |
| { |
| *x = evt->x; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get wheelDeltaY |
| * |
| * \param evt The Event object |
| * \param y The returned wheelDeltaY |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_multi_wheel_event_get_wheel_delta_y( |
| dom_mouse_multi_wheel_event *evt, int32_t *y) |
| { |
| *y = evt->y; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get wheelDeltaZ |
| * |
| * \param evt The Event object |
| * \param z The returned wheelDeltaZ |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_multi_wheel_event_get_wheel_delta_z( |
| dom_mouse_multi_wheel_event *evt, int32_t *z) |
| { |
| *z = evt->z; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Intialise this event with namespace |
| * |
| * \param evt The Event object |
| * \param namespace The namespace of this event |
| * \param type The event's type |
| * \param bubble Whether this is a bubbling event |
| * \param cancelable Whether this is a cancelable event |
| * \param view The AbstractView associated with this event |
| * \param detail The detail information of this mouse event |
| * \param screen_x The x position of the mouse pointer in screen |
| * \param screen_y The y position of the mouse pointer in screen |
| * \param client_x The x position of the mouse pointer in client window |
| * \param client_y The y position of the mouse pointer in client window |
| * \param button The mouse button pressed |
| * \param et The related target of this event, may be NULL |
| * \param modifier_list The string contains the modifier identifier strings |
| * \param wheel_delta_x The wheelDeltaX |
| * \param wheel_delta_y The wheelDeltaY |
| * \param wheel_delta_z The wheelDeltaZ |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_mouse_multi_wheel_event_init_ns( |
| dom_mouse_multi_wheel_event *evt, dom_string *namespace, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_abstract_view *view, int32_t detail, int32_t screen_x, |
| int32_t screen_y, int32_t client_x, int32_t client_y, |
| unsigned short button, dom_event_target *et, |
| dom_string *modifier_list, int32_t wheel_delta_x, |
| int32_t wheel_delta_y, int32_t wheel_delta_z) |
| { |
| dom_exception err; |
| dom_mouse_event *e = (dom_mouse_event *) evt; |
| evt->x = wheel_delta_x; |
| evt->y = wheel_delta_y; |
| evt->z = wheel_delta_z; |
| err = _dom_parse_modifier_list(modifier_list, &e->modifier_state); |
| if (err != DOM_NO_ERR) |
| return err; |
| return _dom_mouse_event_init_ns(&evt->base, namespace, type, bubble, |
| cancelable, view, detail ,screen_x, screen_y, client_x, |
| client_y, false, false, false, false, button, et); |
| } |
| /contrib/network/netsurf/libdom/src/events/mouse_multi_wheel_event.h |
|---|
| 0,0 → 1,44 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_internal_mouse_multi_wheel_event_h_ |
| #define dom_events_internal_mouse_multi_wheel_event_h_ |
| #include <dom/events/mouse_multi_wheel_event.h> |
| #include "events/mouse_event.h" |
| /** |
| * The MouseMultiWheelEvent |
| */ |
| struct dom_mouse_multi_wheel_event { |
| struct dom_mouse_event base; /**< The base class */ |
| int32_t x; /**< The wheelDeltaX */ |
| int32_t y; /**< The wheelDeltaY */ |
| int32_t z; /**< The wheelDeltaZ */ |
| }; |
| /* Constructor */ |
| dom_exception _dom_mouse_multi_wheel_event_create(struct dom_document *doc, |
| struct dom_mouse_multi_wheel_event **evt); |
| /* Destructor */ |
| void _dom_mouse_multi_wheel_event_destroy( |
| struct dom_mouse_multi_wheel_event *evt); |
| /* Initialise function */ |
| dom_exception _dom_mouse_multi_wheel_event_initialise(struct dom_document *doc, |
| struct dom_mouse_multi_wheel_event *evt); |
| /* Finalise function */ |
| #define _dom_mouse_multi_wheel_event_finalise _dom_mouse_event_finalise |
| #endif |
| /contrib/network/netsurf/libdom/src/events/mouse_wheel_event.c |
|---|
| 0,0 → 1,116 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "events/mouse_wheel_event.h" |
| #include "events/keyboard_event.h" |
| #include "core/document.h" |
| #include "utils/utils.h" |
| static void _virtual_dom_mouse_wheel_event_destroy(struct dom_event *evt); |
| static struct dom_event_private_vtable _event_vtable = { |
| _virtual_dom_mouse_wheel_event_destroy |
| }; |
| /* Constructor */ |
| dom_exception _dom_mouse_wheel_event_create(struct dom_document *doc, |
| struct dom_mouse_wheel_event **evt) |
| { |
| *evt = malloc(sizeof(dom_mouse_wheel_event)); |
| if (*evt == NULL) |
| return DOM_NO_MEM_ERR; |
| ((struct dom_event *) *evt)->vtable = &_event_vtable; |
| return _dom_mouse_wheel_event_initialise(doc, |
| (dom_mouse_wheel_event *) *evt); |
| } |
| /* Destructor */ |
| void _dom_mouse_wheel_event_destroy(struct dom_mouse_wheel_event *evt) |
| { |
| _dom_mouse_wheel_event_finalise((dom_ui_event *) evt); |
| free(evt); |
| } |
| /* Initialise function */ |
| dom_exception _dom_mouse_wheel_event_initialise(struct dom_document *doc, |
| struct dom_mouse_wheel_event *evt) |
| { |
| return _dom_mouse_event_initialise(doc, (dom_mouse_event *) evt); |
| } |
| /* The virtual destroy function */ |
| void _virtual_dom_mouse_wheel_event_destroy(struct dom_event *evt) |
| { |
| _dom_mouse_wheel_event_destroy((dom_mouse_wheel_event *) evt); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Get wheelDelta |
| * |
| * \param evt The Event object |
| * \param d The wheelDelta |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mouse_wheel_event_get_wheel_delta( |
| dom_mouse_wheel_event *evt, int32_t *d) |
| { |
| *d = evt->delta; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Intialise this event with namespace |
| * |
| * \param evt The Event object |
| * \param namespace The namespace of this event |
| * \param type The event's type |
| * \param bubble Whether this is a bubbling event |
| * \param cancelable Whether this is a cancelable event |
| * \param view The AbstractView associated with this event |
| * \param detail The detail information of this mouse event |
| * \param screen_x The x position of the mouse pointer in screen |
| * \param screen_y The y position of the mouse pointer in screen |
| * \param client_x The x position of the mouse pointer in client window |
| * \param client_y The y position of the mouse pointer in client window |
| * \param button The mouse button pressed |
| * \param et The related target of this event, may be NULL |
| * \param modifier_list The string contains the modifier identifier strings |
| * \param wheel_delta The wheelDelta |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_mouse_wheel_event_init_ns( |
| dom_mouse_wheel_event *evt, dom_string *namespace, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_abstract_view *view, int32_t detail, int32_t screen_x, |
| int32_t screen_y, int32_t client_x, int32_t client_y, |
| unsigned short button, dom_event_target *et, |
| dom_string *modifier_list, int32_t wheel_delta) |
| { |
| dom_exception err; |
| dom_mouse_event *e = (dom_mouse_event *) evt; |
| evt->delta = wheel_delta; |
| err = _dom_parse_modifier_list(modifier_list, &e->modifier_state); |
| if (err != DOM_NO_ERR) |
| return err; |
| return _dom_mouse_event_init_ns(&evt->base, namespace, type, bubble, |
| cancelable, view, detail ,screen_x, screen_y, |
| client_x, client_y, false, false, false, false, |
| button, et); |
| } |
| /contrib/network/netsurf/libdom/src/events/mouse_wheel_event.h |
|---|
| 0,0 → 1,39 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_events_internal_mouse_wheel_event_h_ |
| #define dom_events_internal_mouse_wheel_event_h_ |
| #include <dom/events/mouse_wheel_event.h> |
| #include "events/mouse_event.h" |
| /** |
| * The MouseWheelEvent |
| */ |
| struct dom_mouse_wheel_event { |
| struct dom_mouse_event base; /**< The base class */ |
| int32_t delta; /**< The wheelDelta */ |
| }; |
| /* Constructor */ |
| dom_exception _dom_mouse_wheel_event_create(struct dom_document *doc, |
| struct dom_mouse_wheel_event **evt); |
| /* Destructor */ |
| void _dom_mouse_wheel_event_destroy(struct dom_mouse_wheel_event *evt); |
| /* Initialise function */ |
| dom_exception _dom_mouse_wheel_event_initialise(struct dom_document *doc, |
| struct dom_mouse_wheel_event *evt); |
| /* Finalise function */ |
| #define _dom_mouse_wheel_event_finalise _dom_mouse_event_finalise |
| #endif |
| /contrib/network/netsurf/libdom/src/events/mutation_event.c |
|---|
| 0,0 → 1,231 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "events/mutation_event.h" |
| #include "core/document.h" |
| static void _virtual_dom_mutation_event_destroy(struct dom_event *evt); |
| static struct dom_event_private_vtable _event_vtable = { |
| _virtual_dom_mutation_event_destroy |
| }; |
| /* Constructor */ |
| dom_exception _dom_mutation_event_create(struct dom_document *doc, |
| struct dom_mutation_event **evt) |
| { |
| *evt = malloc(sizeof(dom_mutation_event)); |
| if (*evt == NULL) |
| return DOM_NO_MEM_ERR; |
| ((struct dom_event *) *evt)->vtable = &_event_vtable; |
| return _dom_mutation_event_initialise(doc, *evt); |
| } |
| /* Destructor */ |
| void _dom_mutation_event_destroy(struct dom_mutation_event *evt) |
| { |
| _dom_mutation_event_finalise(evt); |
| free(evt); |
| } |
| /* Initialise function */ |
| dom_exception _dom_mutation_event_initialise(struct dom_document *doc, |
| struct dom_mutation_event *evt) |
| { |
| evt->related_node = NULL; |
| evt->prev_value = NULL; |
| evt->new_value = NULL; |
| evt->attr_name = NULL; |
| return _dom_event_initialise(doc, &evt->base); |
| } |
| /* Finalise function */ |
| void _dom_mutation_event_finalise(struct dom_mutation_event *evt) |
| { |
| dom_node_unref(evt->related_node); |
| dom_string_unref(evt->prev_value); |
| dom_string_unref(evt->new_value); |
| dom_string_unref(evt->attr_name); |
| evt->related_node = NULL; |
| evt->prev_value = NULL; |
| evt->new_value = NULL; |
| evt->attr_name = NULL; |
| _dom_event_finalise(&evt->base); |
| } |
| /* The virtual destroy function */ |
| void _virtual_dom_mutation_event_destroy(struct dom_event *evt) |
| { |
| _dom_mutation_event_destroy((dom_mutation_event *) evt); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Get the related node |
| * |
| * \param evt The Event object |
| * \param node The related node |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mutation_event_get_related_node(dom_mutation_event *evt, |
| struct dom_node **node) |
| { |
| *node = evt->related_node; |
| dom_node_ref(*node); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the old value |
| * |
| * \param evt The Event object |
| * \param ret The old value |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mutation_event_get_prev_value(dom_mutation_event *evt, |
| dom_string **ret) |
| { |
| *ret = evt->prev_value; |
| dom_string_ref(*ret); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the new value |
| * |
| * \param evt The Event object |
| * \param ret The new value |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mutation_event_get_new_value(dom_mutation_event *evt, |
| dom_string **ret) |
| { |
| *ret = evt->new_value; |
| dom_string_ref(*ret); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the attr name |
| * |
| * \param evt The Event object |
| * \param ret The attribute name |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mutation_event_get_attr_name(dom_mutation_event *evt, |
| dom_string **ret) |
| { |
| *ret = evt->attr_name; |
| dom_string_ref(*ret); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the way the attribute change |
| * |
| * \param evt The Event object |
| * \param type The change type |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mutation_event_get_attr_change(dom_mutation_event *evt, |
| dom_mutation_type *type) |
| { |
| *type = evt->change; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Initialise the MutationEvent |
| * |
| * \param evt The Event object |
| * \param type The type of this UIEvent |
| * \param bubble Whether this event can bubble |
| * \param cancelable Whether this event is cancelable |
| * \param node The mutation node |
| * \param prev_value The old value |
| * \param new_value The new value |
| * \param attr_name The attribute's name |
| * \param change The change type |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_mutation_event_init(dom_mutation_event *evt, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_node *node, dom_string *prev_value, |
| dom_string *new_value, dom_string *attr_name, |
| dom_mutation_type change) |
| { |
| evt->related_node = node; |
| dom_node_ref(node); |
| evt->prev_value = prev_value; |
| dom_string_ref(prev_value); |
| evt->new_value = new_value; |
| dom_string_ref(new_value); |
| evt->attr_name = attr_name; |
| dom_string_ref(attr_name); |
| evt->change = change; |
| return _dom_event_init(&evt->base, type, bubble, cancelable); |
| } |
| /** |
| * Initialise the MutationEvent with namespace |
| * |
| * \param evt The Event object |
| * \param namespace The namespace |
| * \param type The type of this UIEvent |
| * \param bubble Whether this event can bubble |
| * \param cancelable Whether this event is cancelable |
| * \param node The mutation node |
| * \param prev_value The old value |
| * \param new_value The new value |
| * \param attr_name The attribute's name |
| * \param change The change type |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_mutation_event_init_ns(dom_mutation_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, struct dom_node *node, |
| dom_string *prev_value, dom_string *new_value, |
| dom_string *attr_name, dom_mutation_type change) |
| { |
| evt->related_node = node; |
| dom_node_ref(node); |
| evt->prev_value = prev_value; |
| dom_string_ref(prev_value); |
| evt->new_value = new_value; |
| dom_string_ref(new_value); |
| evt->attr_name = attr_name; |
| dom_string_ref(attr_name); |
| evt->change = change; |
| return _dom_event_init_ns(&evt->base, namespace, type, bubble, |
| cancelable); |
| } |
| /contrib/network/netsurf/libdom/src/events/mutation_event.h |
|---|
| 0,0 → 1,43 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_interntal_events_mutation_event_h_ |
| #define dom_interntal_events_mutation_event_h_ |
| #include <dom/events/mutation_event.h> |
| #include "events/event.h" |
| /** |
| * The MutationEvent |
| */ |
| struct dom_mutation_event { |
| struct dom_event base; |
| struct dom_node *related_node; |
| dom_string *prev_value; |
| dom_string *new_value; |
| dom_string *attr_name; |
| dom_mutation_type change; |
| }; |
| /* Constructor */ |
| dom_exception _dom_mutation_event_create(struct dom_document *doc, |
| struct dom_mutation_event **evt); |
| /* Destructor */ |
| void _dom_mutation_event_destroy(struct dom_mutation_event *evt); |
| /* Initialise function */ |
| dom_exception _dom_mutation_event_initialise(struct dom_document *doc, |
| struct dom_mutation_event *evt); |
| /* Finalise function */ |
| void _dom_mutation_event_finalise(struct dom_mutation_event *evt); |
| #endif |
| /contrib/network/netsurf/libdom/src/events/mutation_name_event.c |
|---|
| 0,0 → 1,158 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "events/mutation_name_event.h" |
| #include "core/document.h" |
| #include "utils/utils.h" |
| static void _virtual_dom_mutation_name_event_destroy(struct dom_event *evt); |
| static struct dom_event_private_vtable _event_vtable = { |
| _virtual_dom_mutation_name_event_destroy |
| }; |
| /* Constructor */ |
| dom_exception _dom_mutation_name_event_create(struct dom_document *doc, |
| struct dom_mutation_name_event **evt) |
| { |
| *evt = malloc(sizeof(dom_mutation_name_event)); |
| if (*evt == NULL) |
| return DOM_NO_MEM_ERR; |
| ((struct dom_event *) *evt)->vtable = &_event_vtable; |
| return _dom_mutation_name_event_initialise(doc, *evt); |
| } |
| /* Destructor */ |
| void _dom_mutation_name_event_destroy(struct dom_mutation_name_event *evt) |
| { |
| _dom_mutation_name_event_finalise(evt); |
| free(evt); |
| } |
| /* Initialise function */ |
| dom_exception _dom_mutation_name_event_initialise(struct dom_document *doc, |
| struct dom_mutation_name_event *evt) |
| { |
| evt->prev_namespace = NULL; |
| evt->prev_nodename = NULL; |
| return _dom_event_initialise(doc, (dom_event *) evt); |
| } |
| /* Finalise function */ |
| void _dom_mutation_name_event_finalise(struct dom_mutation_name_event *evt) |
| { |
| dom_string_unref(evt->prev_namespace); |
| dom_string_unref(evt->prev_nodename); |
| _dom_event_finalise((dom_event *) evt); |
| } |
| /* The virtual destroy function */ |
| void _virtual_dom_mutation_name_event_destroy(struct dom_event *evt) |
| { |
| _dom_mutation_name_event_destroy((dom_mutation_name_event *) evt); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Get the previous namespace |
| * |
| * \param evt The Event object |
| * \param namespace The previous namespace of this event |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mutation_name_event_get_prev_namespace( |
| dom_mutation_name_event *evt, dom_string **namespace) |
| { |
| *namespace = evt->prev_namespace; |
| dom_string_ref(*namespace); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the previous node name |
| * |
| * \param evt The Event object |
| * \param name The previous node name |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_mutation_name_event_get_prev_node_name( |
| dom_mutation_name_event *evt, dom_string **name) |
| { |
| *name = evt->prev_nodename; |
| dom_string_ref(*name); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Initialise the MutationNameEvent |
| * |
| * \param evt The Event object |
| * \param type The type of this UIEvent |
| * \param bubble Whether this event can bubble |
| * \param cancelable Whether this event is cancelable |
| * \param node The node whose name change |
| * \param prev_ns The old namespace |
| * \param prev_name The old name |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_mutation_name_event_init(dom_mutation_name_event *evt, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_node *node, dom_string *prev_ns, |
| dom_string *prev_name) |
| { |
| evt->prev_namespace = prev_ns; |
| dom_string_ref(prev_ns); |
| evt->prev_nodename = prev_name; |
| dom_string_ref(prev_name); |
| return _dom_mutation_event_init((dom_mutation_event *) evt, type, |
| bubble, cancelable, node, NULL, NULL, NULL, |
| DOM_MUTATION_MODIFICATION); |
| } |
| /** |
| * Initialise the MutationNameEvent with namespace |
| * |
| * \param evt The Event object |
| * \param namespace The namespace |
| * \param type The type of this UIEvent |
| * \param bubble Whether this event can bubble |
| * \param cancelable Whether this event is cancelable |
| * \param node The node whose name change |
| * \param prev_ns The old namespace |
| * \param prev_name The old name |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_mutation_name_event_init_ns(dom_mutation_name_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, struct dom_node *node, |
| dom_string *prev_ns, dom_string *prev_name) |
| { |
| evt->prev_namespace = prev_ns; |
| dom_string_ref(prev_ns); |
| evt->prev_nodename = prev_name; |
| dom_string_ref(prev_name); |
| return _dom_mutation_event_init_ns((dom_mutation_event *) evt, |
| namespace, type, bubble, cancelable, node, NULL, |
| NULL, NULL, DOM_MUTATION_MODIFICATION); |
| } |
| /contrib/network/netsurf/libdom/src/events/mutation_name_event.h |
|---|
| 0,0 → 1,40 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_interntal_events_mutation_name_event_h_ |
| #define dom_interntal_events_mutation_name_event_h_ |
| #include <dom/events/mutation_name_event.h> |
| #include "events/mutation_event.h" |
| /** |
| * The MutationName event |
| */ |
| struct dom_mutation_name_event { |
| struct dom_mutation_event base; |
| dom_string *prev_namespace; |
| dom_string *prev_nodename; |
| }; |
| /* Constructor */ |
| dom_exception _dom_mutation_name_event_create(struct dom_document *doc, |
| struct dom_mutation_name_event **evt); |
| /* Destructor */ |
| void _dom_mutation_name_event_destroy(struct dom_mutation_name_event *evt); |
| /* Initialise function */ |
| dom_exception _dom_mutation_name_event_initialise(struct dom_document *doc, |
| struct dom_mutation_name_event *evt); |
| /* Finalise function */ |
| void _dom_mutation_name_event_finalise(struct dom_mutation_name_event *evt); |
| #endif |
| /contrib/network/netsurf/libdom/src/events/text_event.c |
|---|
| 0,0 → 1,125 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "events/text_event.h" |
| #include "core/document.h" |
| static void _virtual_dom_text_event_destroy(struct dom_event *evt); |
| static struct dom_event_private_vtable _event_vtable = { |
| _virtual_dom_text_event_destroy |
| }; |
| /* Constructor */ |
| dom_exception _dom_text_event_create(struct dom_document *doc, |
| struct dom_text_event **evt) |
| { |
| *evt = malloc(sizeof(dom_text_event)); |
| if (*evt == NULL) |
| return DOM_NO_MEM_ERR; |
| ((struct dom_event *) *evt)->vtable = &_event_vtable; |
| return _dom_text_event_initialise(doc, *evt); |
| } |
| /* Destructor */ |
| void _dom_text_event_destroy(struct dom_text_event *evt) |
| { |
| _dom_text_event_finalise(evt); |
| free(evt); |
| } |
| /* Initialise function */ |
| dom_exception _dom_text_event_initialise(struct dom_document *doc, |
| struct dom_text_event *evt) |
| { |
| evt->data = NULL; |
| return _dom_ui_event_initialise(doc, &evt->base); |
| } |
| /* Finalise function */ |
| void _dom_text_event_finalise(struct dom_text_event *evt) |
| { |
| dom_string_unref(evt->data); |
| _dom_ui_event_finalise(&evt->base); |
| } |
| /* The virtual destroy function */ |
| void _virtual_dom_text_event_destroy(struct dom_event *evt) |
| { |
| _dom_text_event_destroy((dom_text_event *) evt); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Get the internal data of this event |
| * |
| * \param evt The Event object |
| * \param data The internal data of this Event |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_text_event_get_data(dom_text_event *evt, |
| dom_string **data) |
| { |
| *data = evt->data; |
| dom_string_ref(*data); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Initialise the TextEvent |
| * |
| * \param evt The Event object |
| * \param type The type of this UIEvent |
| * \param bubble Whether this event can bubble |
| * \param cancelable Whether this event is cancelable |
| * \param view The AbstractView of this UIEvent |
| * \param data The text data |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_text_event_init(dom_text_event *evt, |
| dom_string *type, bool bubble, bool cancelable, |
| struct dom_abstract_view *view, dom_string *data) |
| { |
| evt->data = data; |
| dom_string_ref(data); |
| return _dom_ui_event_init(&evt->base, type, bubble, cancelable, |
| view, 0); |
| } |
| /** |
| * Initialise the TextEvent with namespace |
| * |
| * \param evt The Event object |
| * \param namespace The namespace of this Event |
| * \param type The type of this UIEvent |
| * \param bubble Whether this event can bubble |
| * \param cancelable Whether this event is cancelable |
| * \param view The AbstractView of this UIEvent |
| * \param data The text data |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_text_event_init_ns(dom_text_event *evt, |
| dom_string *namespace_name, dom_string *type, |
| bool bubble, bool cancelable, struct dom_abstract_view *view, |
| dom_string *data) |
| { |
| evt->data = data; |
| dom_string_ref(data); |
| return _dom_ui_event_init_ns(&evt->base, namespace_name, type, bubble, |
| cancelable, view, 0); |
| } |
| /contrib/network/netsurf/libdom/src/events/text_event.h |
|---|
| 0,0 → 1,38 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_events_text_event_h_ |
| #define dom_internal_events_text_event_h_ |
| #include <dom/events/text_event.h> |
| #include "events/ui_event.h" |
| /** |
| * The TextEvent |
| */ |
| struct dom_text_event { |
| struct dom_ui_event base; |
| dom_string *data; |
| }; |
| /* Constructor */ |
| dom_exception _dom_text_event_create(struct dom_document *doc, |
| struct dom_text_event **evt); |
| /* Destructor */ |
| void _dom_text_event_destroy(struct dom_text_event *evt); |
| /* Initialise function */ |
| dom_exception _dom_text_event_initialise(struct dom_document *doc, |
| struct dom_text_event *evt); |
| /* Finalise function */ |
| void _dom_text_event_finalise(struct dom_text_event *evt); |
| #endif |
| /contrib/network/netsurf/libdom/src/events/ui_event.c |
|---|
| 0,0 → 1,138 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdlib.h> |
| #include "events/ui_event.h" |
| #include "core/document.h" |
| static void _virtual_dom_ui_event_destroy(struct dom_event *evt); |
| static struct dom_event_private_vtable _event_vtable = { |
| _virtual_dom_ui_event_destroy |
| }; |
| /* Constructor */ |
| dom_exception _dom_ui_event_create(struct dom_document *doc, |
| struct dom_ui_event **evt) |
| { |
| *evt = malloc(sizeof(dom_ui_event)); |
| if (*evt == NULL) |
| return DOM_NO_MEM_ERR; |
| ((struct dom_event *) *evt)->vtable = &_event_vtable; |
| return _dom_ui_event_initialise(doc, *evt); |
| } |
| /* Destructor */ |
| void _dom_ui_event_destroy(struct dom_ui_event *evt) |
| { |
| _dom_ui_event_finalise(evt); |
| free(evt); |
| } |
| /* Initialise function */ |
| dom_exception _dom_ui_event_initialise(struct dom_document *doc, |
| struct dom_ui_event *evt) |
| { |
| evt->view = NULL; |
| return _dom_event_initialise(doc, &evt->base); |
| } |
| /* Finalise function */ |
| void _dom_ui_event_finalise(struct dom_ui_event *evt) |
| { |
| evt->view = NULL; |
| _dom_event_finalise(&evt->base); |
| } |
| /* The virtual destroy function */ |
| void _virtual_dom_ui_event_destroy(struct dom_event *evt) |
| { |
| _dom_ui_event_destroy((dom_ui_event *) evt); |
| } |
| /*----------------------------------------------------------------------*/ |
| /* The public API */ |
| /** |
| * Get the AbstractView inside this event |
| * |
| * \param evt The Event object |
| * \param view The returned AbstractView |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_ui_event_get_view(dom_ui_event *evt, |
| struct dom_abstract_view **view) |
| { |
| *view = evt->view; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the detail param of this event |
| * |
| * \param evt The Event object |
| * \param detail The detail object |
| * \return DOM_NO_ERR. |
| */ |
| dom_exception _dom_ui_event_get_detail(dom_ui_event *evt, |
| int32_t *detail) |
| { |
| *detail = evt->detail; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Initialise the UIEvent |
| * |
| * \param evt The Event object |
| * \param type The type of this UIEvent |
| * \param bubble Whether this event can bubble |
| * \param cancelable Whether this event is cancelable |
| * \param view The AbstractView of this UIEvent |
| * \param detail The detail object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_ui_event_init(dom_ui_event *evt, dom_string *type, |
| bool bubble, bool cancelable, struct dom_abstract_view *view, |
| int32_t detail) |
| { |
| evt->view = view; |
| evt->detail = detail; |
| return _dom_event_init(&evt->base, type, bubble, cancelable); |
| } |
| /** |
| * Initialise the UIEvent with namespace |
| * |
| * \param evt The Event object |
| * \param namespace The namespace of this Event |
| * \param type The type of this UIEvent |
| * \param bubble Whether this event can bubble |
| * \param cancelable Whether this event is cancelable |
| * \param view The AbstractView of this UIEvent |
| * \param detail The detail object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_ui_event_init_ns(dom_ui_event *evt, |
| dom_string *namespace, dom_string *type, |
| bool bubble, bool cancelable, struct dom_abstract_view *view, |
| int32_t detail) |
| { |
| evt->view = view; |
| evt->detail = detail; |
| return _dom_event_init_ns(&evt->base, namespace, type, bubble, |
| cancelable); |
| } |
| /contrib/network/netsurf/libdom/src/events/ui_event.h |
|---|
| 0,0 → 1,52 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_interntal_events_ui_event_h_ |
| #define dom_interntal_events_ui_event_h_ |
| #include <dom/events/ui_event.h> |
| #include "events/event.h" |
| /** |
| * The modifier key state |
| */ |
| typedef enum { |
| DOM_MOD_CTRL = (1<<0), |
| DOM_MOD_META = (1<<1), |
| DOM_MOD_SHIFT = (1<<2), |
| DOM_MOD_ALT = (1<<3), |
| DOM_MOD_ALT_GRAPH = (1<<4), |
| DOM_MOD_CAPS_LOCK = (1<<5), |
| DOM_MOD_NUM_LOCK = (1<<6), |
| DOM_MOD_SCROLL = (1<<7) |
| } dom_modifier_key; |
| /** |
| * The UIEvent |
| */ |
| struct dom_ui_event { |
| struct dom_event base; /**< The base class */ |
| struct dom_abstract_view *view; /**< The AbstractView */ |
| int32_t detail; /**< Some private data for this event */ |
| }; |
| /* Constructor */ |
| dom_exception _dom_ui_event_create(struct dom_document *doc, |
| struct dom_ui_event **evt); |
| /* Destructor */ |
| void _dom_ui_event_destroy(struct dom_ui_event *evt); |
| /* Initialise function */ |
| dom_exception _dom_ui_event_initialise(struct dom_document *doc, |
| struct dom_ui_event *evt); |
| /* Finalise function */ |
| void _dom_ui_event_finalise(struct dom_ui_event *evt); |
| #endif |
| /contrib/network/netsurf/libdom/src/html/Makefile |
|---|
| 0,0 → 1,30 |
| # Sources |
| OBJS := \ |
| html_document.o html_collection.o html_options_collection.o \ |
| html_element.o html_html_element.o html_head_element.o \ |
| html_link_element.o html_title_element.o html_meta_element.o \ |
| html_base_element.o html_isindex_element.o html_style_element.o \ |
| html_body_element.o html_form_element.o html_select_element.o \ |
| html_button_element.o html_input_element.o html_text_area_element.o \ |
| html_opt_group_element.o html_option_element.o |
| UNINMPLEMENTED_SOURCES := \ |
| html_label_element.c html_fieldset_element.c \ |
| html_legend_element.c html_ulist_element.c html_olist_element.c \ |
| html_dlist_element.c html_directory_element.c html_menu_element.c \ |
| html_li_element.c html_div_element.c html_paragraph_element.c \ |
| html_heading_element.c html_quote_element.c html_pre_element.c \ |
| html_br_element.c html_basefont_element.c html_font_element.c \ |
| html_hr_element.c html_mod_element.c html_anchor_element.c \ |
| html_image_element.c html_object_element.c html_param_element.c \ |
| html_applet_element.c html_map_element.c html_area_element.c \ |
| html_script_element.c html_table_element.c html_tablecaption_element.c \ |
| html_tablecol_element.c html_tablesection_element.c html_tablerow_element.c \ |
| html_tablecell_element.c html_frameset_element.c html_frame_element.c \ |
| html_iframe_element.c |
| OUTFILE = libo.o |
| CFLAGS += -I ../../include/ -I ../../ -I ../ -I ./ -I /home/sourcerer/kos_src/newenginek/kolibri/include |
| include $(MENUETDEV)/makefiles/Makefile_for_o_lib |
| /contrib/network/netsurf/libdom/src/html/TODO |
|---|
| 0,0 → 1,57 |
| The following is the status of the HTML Element and derived objects, at least |
| as far as the test suite is concerned. |
| HTMLElement html_element DONE |
| HTMLHtmlElement html_html_element DONE |
| HTMLHeadElement html_head_element DONE |
| HTMLLinkElement html_link_element MISSING |
| HTMLTitleElement html_title_element DONE |
| HTMLMetaElement html_meta_element MISSING |
| HTMLBaseElement html_base_element MISSING |
| HTMLIsIndexElement html_isindex_element MISSING |
| HTMLStyleElement html_style_element MISSING |
| HTMLBodyElement html_body_element MISSING |
| HTMLFormElement html_form_element DONE |
| HTMLSelectElement html_select_element MISSING |
| HTMLOptGroupElement html_optgroup_element MISSING |
| HTMLOptionElement html_option_element MISSING |
| HTMLInputElement html_input_element MISSING |
| HTMLTextAreaElement html_textarea_element MISSING |
| HTMLButtonElement html_button_element MISSING |
| HTMLLabelElement html_label_element MISSING |
| HTMLFieldSetElement html_fieldset_element MISSING |
| HTMLLegendElement html_legend_element MISSING |
| HTMLUListElement html_ulist_element MISSING |
| HTMLOListElement html_olist_element MISSING |
| HTMLDListElement html_dlist_element MISSING |
| HTMLDirectoryElement html_directory_element MISSING |
| HTMLMenuElement html_menu_element MISSING |
| HTMLLIElement html_li_element MISSING |
| HTMLBlockquoteElement html_blockquote_element MISSING |
| HTMLDivElement html_div_element MISSING |
| HTMLParagraphElement html_paragraph_element MISSING |
| HTMLHeadingElement html_heading_element MISSING |
| HTMLQuoteElement html_quote_element MISSING |
| HTMLPreElement html_pre_element MISSING |
| HTMLBRElement html_br_element MISSING |
| HTMLBaseFontElement html_basefont_element MISSING |
| HTMLFontElement html_font_element MISSING |
| HTMLHRElement html_hr_element MISSING |
| HTMLModElement html_mod_element MISSING |
| HTMLAnchorElement html_anchor_element MISSING |
| HTMLImageElement html_image_element MISSING |
| HTMLObjectElement html_object_element MISSING |
| HTMLParamElement html_param_element MISSING |
| HTMLAppletElement html_applet_element MISSING |
| HTMLMapElement html_map_element MISSING |
| HTMLAreaElement html_area_element MISSING |
| HTMLScriptElement html_script_element MISSING |
| HTMLTableElement html_table_element MISSING |
| HTMLTableCaptionElement html_tablecaption_element MISSING |
| HTMLTableColElement html_tablecol_element MISSING |
| HTMLTableSectionElement html_tablesection_element MISSING |
| HTMLTableRowElement html_tablerow_element MISSING |
| HTMLTableCellElement html_tablecell_element MISSING |
| HTMLFrameSetElement html_frameset_element MISSING |
| HTMLFrameElement html_frame_element MISSING |
| HTMLIFrameElement html_iframe_element MISSING |
| /contrib/network/netsurf/libdom/src/html/html_anchor_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_anchor_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_applet_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_applet_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_area_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_area_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_base_element.c |
|---|
| 0,0 → 1,120 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <stdlib.h> |
| #include "html/html_base_element.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_BASE_ELEMENT |
| }, |
| DOM_HTML_BASE_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_base_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_base_element_create(struct dom_html_document *doc, |
| struct dom_html_base_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_base_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_base_element_initialise(doc, *ele); |
| } |
| /** |
| * Initialise a dom_html_base_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_base_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_base_element_initialise(struct dom_html_document *doc, |
| struct dom_html_base_element *ele) |
| { |
| dom_string *name = NULL; |
| dom_exception err; |
| err = dom_string_create((const uint8_t *) "BASE", SLEN("BASE"), &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_html_element_initialise(doc, &ele->base, name, NULL, NULL); |
| dom_string_unref(name); |
| return err; |
| } |
| /** |
| * Finalise a dom_html_base_element object |
| * |
| * \param ele The dom_html_base_element object |
| */ |
| void _dom_html_base_element_finalise(struct dom_html_base_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_base_element object |
| * |
| * \param ele The dom_html_base_element object |
| */ |
| void _dom_html_base_element_destroy(struct dom_html_base_element *ele) |
| { |
| _dom_html_base_element_finalise(ele); |
| free(ele); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_base_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_base_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_base_element_destroy((struct dom_html_base_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_base_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /contrib/network/netsurf/libdom/src/html/html_base_element.h |
|---|
| 0,0 → 1,50 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_internal_html_base_element_h_ |
| #define dom_internal_html_base_element_h_ |
| #include <dom/html/html_base_element.h> |
| #include "html/html_element.h" |
| struct dom_html_base_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| }; |
| /* Create a dom_html_base_element object */ |
| dom_exception _dom_html_base_element_create(struct dom_html_document *doc, |
| struct dom_html_base_element **ele); |
| /* Initialise a dom_html_base_element object */ |
| dom_exception _dom_html_base_element_initialise(struct dom_html_document *doc, |
| struct dom_html_base_element *ele); |
| /* Finalise a dom_html_base_element object */ |
| void _dom_html_base_element_finalise(struct dom_html_base_element *ele); |
| /* Destroy a dom_html_base_element object */ |
| void _dom_html_base_element_destroy(struct dom_html_base_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_base_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_base_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_base_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_BASE_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_base_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_BASE_ELEMENT \ |
| _dom_virtual_html_base_element_destroy, \ |
| _dom_html_base_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_basefont_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_basefont_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_body_element.c |
|---|
| 0,0 → 1,162 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <stdlib.h> |
| #include <dom/html/html_body_element.h> |
| #include "html/html_body_element.h" |
| #include "html/html_document.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_BODY_ELEMENT |
| }, |
| DOM_HTML_BODY_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_body_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_body_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_body_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_body_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_body_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_body_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_body_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_body_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_body_element *ele) |
| { |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_BODY], namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_body_element object |
| * |
| * \param ele The dom_html_body_element object |
| */ |
| void _dom_html_body_element_finalise(struct dom_html_body_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_body_element object |
| * |
| * \param ele The dom_html_body_element object |
| */ |
| void _dom_html_body_element_destroy(struct dom_html_body_element *ele) |
| { |
| _dom_html_body_element_finalise(ele); |
| free(ele); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_body_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_body_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_body_element_destroy((struct dom_html_body_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_body_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* API functions */ |
| #define SIMPLE_GET(attr) \ |
| dom_exception dom_html_body_element_get_##attr( \ |
| dom_html_body_element *element, \ |
| dom_string **attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_get_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| #define SIMPLE_SET(attr) \ |
| dom_exception dom_html_body_element_set_##attr( \ |
| dom_html_body_element *element, \ |
| dom_string *attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_set_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| #define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) |
| SIMPLE_GET_SET(a_link) |
| SIMPLE_GET_SET(background) |
| SIMPLE_GET_SET(bg_color) |
| SIMPLE_GET_SET(link) |
| SIMPLE_GET_SET(text) |
| SIMPLE_GET_SET(v_link) |
| /contrib/network/netsurf/libdom/src/html/html_body_element.h |
|---|
| 0,0 → 1,52 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_internal_html_body_element_h_ |
| #define dom_internal_html_body_element_h_ |
| #include <dom/html/html_body_element.h> |
| #include "html/html_element.h" |
| struct dom_html_body_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| }; |
| /* Create a dom_html_body_element object */ |
| dom_exception _dom_html_body_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_body_element **ele); |
| /* Initialise a dom_html_body_element object */ |
| dom_exception _dom_html_body_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_body_element *ele); |
| /* Finalise a dom_html_body_element object */ |
| void _dom_html_body_element_finalise(struct dom_html_body_element *ele); |
| /* Destroy a dom_html_body_element object */ |
| void _dom_html_body_element_destroy(struct dom_html_body_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_body_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_body_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_body_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_BODY_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_body_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_BODY_ELEMENT \ |
| _dom_virtual_html_body_element_destroy, \ |
| _dom_html_body_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_br_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_br_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_button_element.c |
|---|
| 0,0 → 1,230 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/html/html_button_element.h> |
| #include "html/html_document.h" |
| #include "html/html_button_element.h" |
| #include "core/node.h" |
| #include "core/attr.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_BUTTON_ELEMENT |
| }, |
| DOM_HTML_BUTTON_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_button_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_button_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_button_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_button_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_button_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_button_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_button_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_button_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_button_element *ele) |
| { |
| ele->form = NULL; |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_BUTTON], |
| namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_button_element object |
| * |
| * \param ele The dom_html_button_element object |
| */ |
| void _dom_html_button_element_finalise(struct dom_html_button_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_button_element object |
| * |
| * \param ele The dom_html_button_element object |
| */ |
| void _dom_html_button_element_destroy(struct dom_html_button_element *ele) |
| { |
| _dom_html_button_element_finalise(ele); |
| free(ele); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| /** |
| * Get the disabled property |
| * |
| * \param ele The dom_html_button_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_button_element_get_disabled(dom_html_button_element *ele, |
| bool *disabled) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /** |
| * Set the disabled property |
| * |
| * \param ele The dom_html_button_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_button_element_set_disabled(dom_html_button_element *ele, |
| bool disabled) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_button_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_button_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_button_element_destroy((struct dom_html_button_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_button_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* API functions */ |
| #define SIMPLE_GET(attr) \ |
| dom_exception dom_html_button_element_get_##attr( \ |
| dom_html_button_element *element, \ |
| dom_string **attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_get_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| #define SIMPLE_SET(attr) \ |
| dom_exception dom_html_button_element_set_##attr( \ |
| dom_html_button_element *element, \ |
| dom_string *attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_set_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| #define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) |
| SIMPLE_GET_SET(access_key); |
| SIMPLE_GET_SET(name); |
| SIMPLE_GET(type); |
| SIMPLE_GET_SET(value); |
| dom_exception dom_html_button_element_get_tab_index( |
| dom_html_button_element *button, int32_t *tab_index) |
| { |
| return dom_html_element_get_int32_t_property(&button->base, "tabindex", |
| SLEN("tabindex"), tab_index); |
| } |
| dom_exception dom_html_button_element_set_tab_index( |
| dom_html_button_element *button, uint32_t tab_index) |
| { |
| return dom_html_element_set_int32_t_property(&button->base, "tabindex", |
| SLEN("tabindex"), tab_index); |
| } |
| dom_exception dom_html_button_element_get_form( |
| dom_html_button_element *button, dom_html_form_element **form) |
| { |
| *form = button->form; |
| if (*form != NULL) |
| dom_node_ref(*form); |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_html_button_element_set_form( |
| dom_html_button_element *button, dom_html_form_element *form) |
| { |
| button->form = form; |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/html/html_button_element.h |
|---|
| 0,0 → 1,59 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_html_button_element_h_ |
| #define dom_internal_html_button_element_h_ |
| #include <dom/html/html_button_element.h> |
| #include "html/html_element.h" |
| struct dom_html_button_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| struct dom_html_form_element *form; |
| /**< The form associated with the button */ |
| }; |
| /* Create a dom_html_button_element object */ |
| dom_exception _dom_html_button_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_button_element **ele); |
| /* Initialise a dom_html_button_element object */ |
| dom_exception _dom_html_button_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_button_element *ele); |
| /* Finalise a dom_html_button_element object */ |
| void _dom_html_button_element_finalise(struct dom_html_button_element *ele); |
| /* Destroy a dom_html_button_element object */ |
| void _dom_html_button_element_destroy(struct dom_html_button_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_button_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_button_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_button_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_BUTTON_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_button_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_BUTTON_ELEMENT \ |
| _dom_virtual_html_button_element_destroy, \ |
| _dom_html_button_element_copy |
| /* Internal function for bindings */ |
| dom_exception _dom_html_button_element_set_form( |
| dom_html_button_element *button, dom_html_form_element *form); |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_collection.c |
|---|
| 0,0 → 1,297 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <libwapcaplet/libwapcaplet.h> |
| #include "html/html_collection.h" |
| #include "core/node.h" |
| #include "core/element.h" |
| #include "core/string.h" |
| /*-----------------------------------------------------------------------*/ |
| /* Constructor and destructor */ |
| /** |
| * Create a dom_html_collection |
| * |
| * \param doc The document |
| * \param root The root element of the collection |
| * \param ic The callback function used to determin whether certain node |
| * beint32_ts to the collection |
| * \param col The result collection object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_collection_create(struct dom_html_document *doc, |
| struct dom_node_internal *root, |
| dom_callback_is_in_collection ic, |
| void *ctx, |
| struct dom_html_collection **col) |
| { |
| *col = malloc(sizeof(dom_html_collection)); |
| if (*col == NULL) |
| return DOM_NO_MEM_ERR; |
| return _dom_html_collection_initialise(doc, *col, root, ic, ctx); |
| } |
| /** |
| * Intialiase a dom_html_collection |
| * |
| * \param doc The document |
| * \param col The collection object to be initialised |
| * \param root The root element of the collection |
| * \param ic The callback function used to determin whether certain node |
| * beint32_ts to the collection |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception _dom_html_collection_initialise(struct dom_html_document *doc, |
| struct dom_html_collection *col, |
| struct dom_node_internal *root, |
| dom_callback_is_in_collection ic, void *ctx) |
| { |
| assert(doc != NULL); |
| assert(ic != NULL); |
| assert(root != NULL); |
| col->doc = doc; |
| dom_node_ref(doc); |
| col->root = root; |
| dom_node_ref(root); |
| col->ic = ic; |
| col->ctx = ctx; |
| col->refcnt = 1; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Finalise a dom_html_collection object |
| * |
| * \param col The dom_html_collection object |
| */ |
| void _dom_html_collection_finalise(struct dom_html_collection *col) |
| { |
| dom_node_unref(col->doc); |
| col->doc = NULL; |
| dom_node_unref(col->root); |
| col->root = NULL; |
| col->ic = NULL; |
| } |
| /** |
| * Destroy a dom_html_collection object |
| * \param col The dom_html_collection object |
| */ |
| void _dom_html_collection_destroy(struct dom_html_collection *col) |
| { |
| _dom_html_collection_finalise(col); |
| free(col); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public API */ |
| /** |
| * Get the length of this dom_html_collection |
| * |
| * \param col The dom_html_collection object |
| * \param len The returned length of this collection |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_collection_get_length(dom_html_collection *col, |
| uint32_t *len) |
| { |
| struct dom_node_internal *node = col->root; |
| *len = 0; |
| while (node != NULL) { |
| if (node->type == DOM_ELEMENT_NODE && |
| col->ic(node, col->ctx) == true) |
| (*len)++; |
| /* Depth first iterating */ |
| if (node->first_child != NULL) { |
| node = node->first_child; |
| } else if (node->next != NULL) { |
| node = node->next; |
| } else { |
| /* No children and siblings */ |
| struct dom_node_internal *parent = node->parent; |
| while (parent != col->root && |
| node == parent->last_child) { |
| node = parent; |
| parent = parent->parent; |
| } |
| if (node == col->root) |
| node = NULL; |
| else |
| node = node->next; |
| } |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the node with certain index |
| * |
| * \param col The dom_html_collection object |
| * \param index The index number based on zero |
| * \param node The returned node object |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_collection_item(dom_html_collection *col, |
| uint32_t index, struct dom_node **node) |
| { |
| struct dom_node_internal *n = col->root; |
| uint32_t len = 0; |
| while (n != NULL) { |
| if (n->type == DOM_ELEMENT_NODE && |
| col->ic(n, col->ctx) == true) |
| len++; |
| if (len == index + 1) { |
| dom_node_ref(n); |
| *node = (struct dom_node *) n; |
| return DOM_NO_ERR; |
| } |
| /* Depth first iterating */ |
| if (n->first_child != NULL) { |
| n = n->first_child; |
| } else if (n->next != NULL) { |
| n = n->next; |
| } else { |
| /* No children and siblings */ |
| struct dom_node_internal *parent = n->parent; |
| while (parent != col->root && |
| n == parent->last_child) { |
| n = parent; |
| parent = parent->parent; |
| } |
| if (n == col->root) |
| n = NULL; |
| else |
| n = n->next; |
| } |
| } |
| /* Not find the node */ |
| *node = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the node in the collection according name |
| * |
| * \param col The collection |
| * \param name The name of target node |
| * \param node The returned node object |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_collection_named_item(dom_html_collection *col, |
| dom_string *name, struct dom_node **node) |
| { |
| struct dom_node_internal *n = col->root; |
| dom_exception err; |
| while (n != NULL) { |
| if (n->type == DOM_ELEMENT_NODE && |
| col->ic(n, col->ctx) == true) { |
| dom_string *id = NULL; |
| err = _dom_element_get_id((struct dom_element *) n, |
| &id); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| if (id != NULL && dom_string_isequal(name, id)) { |
| *node = (struct dom_node *) n; |
| dom_node_ref(n); |
| dom_string_unref(id); |
| return DOM_NO_ERR; |
| } |
| if (id != NULL) |
| dom_string_unref(id); |
| } |
| /* Depth first iterating */ |
| if (n->first_child != NULL) { |
| n = n->first_child; |
| } else if (n->next != NULL) { |
| n = n->next; |
| } else { |
| /* No children and siblings */ |
| struct dom_node_internal *parent = n->parent; |
| while (parent != col->root && |
| n == parent->last_child) { |
| n = parent; |
| parent = parent->parent; |
| } |
| if (parent == col->root) |
| n = NULL; |
| else |
| n = n->next; |
| } |
| } |
| /* Not found the target node */ |
| *node = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Claim a reference on this collection |
| * |
| * \pram col The collection object |
| */ |
| void dom_html_collection_ref(dom_html_collection *col) |
| { |
| if (col == NULL) |
| return; |
| col->refcnt ++; |
| } |
| /** |
| * Relese a reference on this collection |
| * |
| * \pram col The collection object |
| */ |
| void dom_html_collection_unref(dom_html_collection *col) |
| { |
| if (col == NULL) |
| return; |
| if (col->refcnt > 0) |
| col->refcnt --; |
| if (col->refcnt == 0) |
| _dom_html_collection_destroy(col); |
| } |
| /contrib/network/netsurf/libdom/src/html/html_collection.h |
|---|
| 0,0 → 1,53 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_html_collection_h_ |
| #define dom_internal_html_collection_h_ |
| #include <dom/html/html_collection.h> |
| struct dom_node_internal; |
| typedef bool (*dom_callback_is_in_collection)( |
| struct dom_node_internal *node, void *ctx); |
| /** |
| * The html_collection structure |
| */ |
| struct dom_html_collection { |
| dom_callback_is_in_collection ic; |
| /**< The function pointer used to test |
| * whether some node is an element of |
| * this collection |
| */ |
| void *ctx; /**< Context for the callback */ |
| struct dom_html_document *doc; /**< The document created this |
| * collection |
| */ |
| struct dom_node_internal *root; |
| /**< The root node of this collection */ |
| uint32_t refcnt; |
| /**< Reference counting */ |
| }; |
| dom_exception _dom_html_collection_create(struct dom_html_document *doc, |
| struct dom_node_internal *root, |
| dom_callback_is_in_collection ic, |
| void *ctx, |
| struct dom_html_collection **col); |
| dom_exception _dom_html_collection_initialise(struct dom_html_document *doc, |
| struct dom_html_collection *col, |
| struct dom_node_internal *root, |
| dom_callback_is_in_collection ic, void *ctx); |
| void _dom_html_collection_finalise(struct dom_html_collection *col); |
| void _dom_html_collection_destroy(struct dom_html_collection *col); |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_directory_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_directory_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_div_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_div_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_dlist_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_dlist_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_document.c |
|---|
| 0,0 → 1,633 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include "html/html_document.h" |
| #include "html/html_element.h" |
| #include "html/html_collection.h" |
| #include "html/html_html_element.h" |
| #include "html/html_head_element.h" |
| #include "html/html_body_element.h" |
| #include "html/html_link_element.h" |
| #include "html/html_title_element.h" |
| #include "html/html_meta_element.h" |
| #include "html/html_form_element.h" |
| #include "html/html_button_element.h" |
| #include "html/html_input_element.h" |
| #include "html/html_text_area_element.h" |
| #include "html/html_opt_group_element.h" |
| #include "html/html_option_element.h" |
| #include "html/html_select_element.h" |
| #include "core/attr.h" |
| #include "core/string.h" |
| #include "utils/namespace.h" |
| #include "utils/utils.h" |
| static struct dom_html_document_vtable html_document_vtable = { |
| { |
| { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE |
| }, |
| DOM_NODE_VTABLE, |
| }, |
| DOM_DOCUMENT_VTABLE_HTML |
| }, |
| DOM_HTML_DOCUMENT_VTABLE |
| }; |
| static struct dom_node_protect_vtable html_document_protect_vtable = { |
| DOM_HTML_DOCUMENT_PROTECT_VTABLE |
| }; |
| /* Create a HTMLDocument */ |
| dom_exception _dom_html_document_create( |
| dom_events_default_action_fetcher daf, |
| void *daf_ctx, |
| dom_html_document **doc) |
| { |
| dom_exception error; |
| dom_html_document *result; |
| result = malloc(sizeof(dom_html_document)); |
| if (result == NULL) |
| return DOM_NO_MEM_ERR; |
| result->base.base.base.vtable = &html_document_vtable; |
| result->base.base.vtable = &html_document_protect_vtable; |
| error = _dom_html_document_initialise(result, daf, daf_ctx); |
| if (error != DOM_NO_ERR) { |
| free(result); |
| return error; |
| } |
| *doc = result; |
| return DOM_NO_ERR; |
| } |
| /* Initialise a HTMLDocument */ |
| dom_exception _dom_html_document_initialise(dom_html_document *doc, |
| dom_events_default_action_fetcher daf, |
| void *daf_ctx) |
| { |
| dom_exception error; |
| int sidx; |
| error = _dom_document_initialise(&doc->base, daf, daf_ctx); |
| if (error != DOM_NO_ERR) |
| return error; |
| doc->title = NULL; |
| doc->referrer = NULL; |
| doc->domain = NULL; |
| doc->url = NULL; |
| doc->cookie = NULL; |
| doc->memoised = calloc(sizeof(dom_string *), hds_COUNT); |
| if (doc->memoised == NULL) { |
| error = DOM_NO_MEM_ERR; |
| goto out; |
| } |
| #define HTML_DOCUMENT_STRINGS_ACTION(attr,str) \ |
| error = dom_string_create_interned((const uint8_t *) #str, \ |
| SLEN(#str), &doc->memoised[hds_##attr]); \ |
| if (error != DOM_NO_ERR) { \ |
| goto out; \ |
| } |
| #include "html_document_strings.h" |
| #undef HTML_DOCUMENT_STRINGS_ACTION |
| out: |
| if (doc->memoised != NULL && error != DOM_NO_ERR) { |
| for(sidx = 0; sidx < hds_COUNT; ++sidx) { |
| if (doc->memoised[sidx] != NULL) { |
| dom_string_unref(doc->memoised[sidx]); |
| } |
| } |
| free(doc->memoised); |
| doc->memoised = NULL; |
| } |
| return error; |
| } |
| /* Finalise a HTMLDocument */ |
| bool _dom_html_document_finalise(dom_html_document *doc) |
| { |
| int sidx; |
| if (doc->cookie != NULL) |
| dom_string_unref(doc->cookie); |
| if (doc->url != NULL) |
| dom_string_unref(doc->url); |
| if (doc->domain != NULL) |
| dom_string_unref(doc->domain); |
| if (doc->referrer != NULL) |
| dom_string_unref(doc->referrer); |
| if (doc->title != NULL) |
| dom_string_unref(doc->title); |
| if (doc->memoised != NULL) { |
| for(sidx = 0; sidx < hds_COUNT; ++sidx) { |
| if (doc->memoised[sidx] != NULL) { |
| dom_string_unref(doc->memoised[sidx]); |
| } |
| } |
| free(doc->memoised); |
| doc->memoised = NULL; |
| } |
| return _dom_document_finalise(&doc->base); |
| } |
| /* Destroy a HTMLDocument */ |
| void _dom_html_document_destroy(dom_node_internal *node) |
| { |
| dom_html_document *doc = (dom_html_document *) node; |
| if (_dom_html_document_finalise(doc) == true) |
| free(doc); |
| } |
| dom_exception _dom_html_document_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| UNUSED(old); |
| UNUSED(copy); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /* Overloaded methods inherited from super class */ |
| /** Internal method to support both kinds of create method */ |
| static dom_exception |
| _dom_html_document_create_element_internal(dom_html_document *html, |
| dom_string *in_tag_name, |
| dom_string *namespace, |
| dom_string *prefix, |
| dom_html_element **result) |
| { |
| dom_exception exc; |
| dom_string *tag_name; |
| exc = dom_string_toupper(in_tag_name, true, &tag_name); |
| if (exc != DOM_NO_ERR) |
| return exc; |
| if (dom_string_caseless_isequal(tag_name, html->memoised[hds_HTML])) { |
| exc = _dom_html_html_element_create(html, namespace, prefix, |
| (dom_html_html_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_HEAD])) { |
| exc = _dom_html_head_element_create(html, namespace, prefix, |
| (dom_html_head_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_TITLE])) { |
| exc = _dom_html_title_element_create(html, namespace, prefix, |
| (dom_html_title_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_BODY])) { |
| exc = _dom_html_body_element_create(html, namespace, prefix, |
| (dom_html_body_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_FORM])) { |
| exc = _dom_html_form_element_create(html, namespace, prefix, |
| (dom_html_form_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_LINK])) { |
| exc = _dom_html_link_element_create(html, namespace, prefix, |
| (dom_html_link_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_BUTTON])) { |
| exc = _dom_html_button_element_create(html, namespace, prefix, |
| (dom_html_button_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_INPUT])) { |
| exc = _dom_html_input_element_create(html, namespace, prefix, |
| (dom_html_input_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_TEXTAREA])) { |
| exc = _dom_html_text_area_element_create(html, namespace, prefix, |
| (dom_html_text_area_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_OPTGROUP])) { |
| exc = _dom_html_opt_group_element_create(html, namespace, prefix, |
| (dom_html_opt_group_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_OPTION])) { |
| exc = _dom_html_option_element_create(html, namespace, prefix, |
| (dom_html_option_element **) result); |
| } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_SELECT])) { |
| exc = _dom_html_select_element_create(html, namespace, prefix, |
| (dom_html_select_element **) result); |
| } else { |
| exc = _dom_html_element_create(html, tag_name, namespace, |
| prefix, result); |
| } |
| dom_string_unref(tag_name); |
| return exc; |
| } |
| dom_exception _dom_html_document_create_element(dom_document *doc, |
| dom_string *tag_name, dom_element **result) |
| { |
| dom_html_document *html = (dom_html_document *) doc; |
| return _dom_html_document_create_element_internal(html, |
| tag_name, NULL, NULL, |
| (dom_html_element **)result); |
| } |
| dom_exception _dom_html_document_create_element_ns(dom_document *doc, |
| dom_string *namespace, dom_string *qname, |
| dom_element **result) |
| { |
| dom_html_document *html = (dom_html_document *) doc; |
| dom_string *prefix, *localname; |
| dom_exception err; |
| /* Divide QName into prefix/localname pair */ |
| err = _dom_namespace_split_qname(qname, &prefix, &localname); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Attempt to create element */ |
| err = _dom_html_document_create_element_internal(html, localname, |
| namespace, prefix, (dom_html_element **)result); |
| /* Tidy up */ |
| if (localname != NULL) { |
| dom_string_unref(localname); |
| } |
| if (prefix != NULL) { |
| dom_string_unref(prefix); |
| } |
| return err; |
| } |
| /** |
| * Create an attribute |
| * |
| * \param doc The document owning the attribute |
| * \param name The name of the attribute |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * |
| * The constructed attribute will always be classified as 'specified'. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_html_document_create_attribute(dom_document *doc, |
| dom_string *name, dom_attr **result) |
| { |
| return _dom_attr_create(doc, name, NULL, NULL, true, result); |
| } |
| /** |
| * Create an attribute from the qualified name and namespace URI |
| * |
| * \param doc The document owning the attribute |
| * \param namespace The namespace URI to use |
| * \param qname The qualified name of the attribute |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_NAMESPACE_ERR if ::qname is malformed, or it has a |
| * prefix and ::namespace is NULL, or |
| * ::qname has a prefix "xml" and |
| * ::namespace is not |
| * "http://www.w3.org/XML/1998/namespace", |
| * or ::qname has a prefix "xmlns" and |
| * ::namespace is not |
| * "http://www.w3.org/2000/xmlns", or |
| * ::namespace is |
| * "http://www.w3.org/2000/xmlns" and |
| * ::qname is not (or is not prefixed by) |
| * "xmlns", |
| * DOM_NOT_SUPPORTED_ERR if ::doc does not support the "XML" |
| * feature. |
| * |
| * The returned node will have its reference count increased. It is |
| * the responsibility of the caller to unref the node once it has |
| * finished with it. |
| */ |
| dom_exception _dom_html_document_create_attribute_ns(dom_document *doc, |
| dom_string *namespace, dom_string *qname, |
| dom_attr **result) |
| { |
| dom_string *prefix, *localname; |
| dom_exception err; |
| /* Divide QName into prefix/localname pair */ |
| err = _dom_namespace_split_qname(qname, &prefix, &localname); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| /* Attempt to create attribute */ |
| err = _dom_attr_create(doc, localname, namespace, prefix, true, result); |
| /* Tidy up */ |
| if (localname != NULL) { |
| dom_string_unref(localname); |
| } |
| if (prefix != NULL) { |
| dom_string_unref(prefix); |
| } |
| return err; |
| } |
| /** |
| * Retrieve a list of all elements with a given tag name |
| * |
| * \param doc The document to search in |
| * \param tagname The tag name to search for ("*" for all) |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned list will have its reference count increased. It is |
| * the responsibility of the caller to unref the list once it has |
| * finished with it. |
| */ |
| dom_exception _dom_html_document_get_elements_by_tag_name(dom_document *doc, |
| dom_string *tagname, dom_nodelist **result) |
| { |
| return _dom_document_get_nodelist(doc, DOM_NODELIST_BY_NAME_CASELESS, |
| (dom_node_internal *) doc, tagname, NULL, NULL, |
| result); |
| } |
| /** |
| * Retrieve a list of all elements with a given local name and namespace URI |
| * |
| * \param doc The document to search in |
| * \param namespace The namespace URI |
| * \param localname The local name |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| * |
| * The returned list will have its reference count increased. It is |
| * the responsibility of the caller to unref the list once it has |
| * finished with it. |
| */ |
| dom_exception _dom_html_document_get_elements_by_tag_name_ns( |
| dom_document *doc, dom_string *namespace, |
| dom_string *localname, dom_nodelist **result) |
| { |
| return _dom_document_get_nodelist(doc, DOM_NODELIST_BY_NAMESPACE_CASELESS, |
| (dom_node_internal *) doc, NULL, namespace, localname, |
| result); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* The DOM spec public API */ |
| /** |
| * Get the title of this HTMLDocument |
| * \param doc The document object |
| * \param title The reutrned title string |
| * \return DOM_NO_ERR on success, appropriated dom_exception on failure. |
| * |
| * @note: this method find a title for the document as following: |
| * 1. If there is a title in the document object set by |
| * dom_html_document_set_title, then use it; |
| * 2. If there is no such one, find the <title> element and use its text |
| * as the returned title. |
| */ |
| dom_exception _dom_html_document_get_title(dom_html_document *doc, |
| dom_string **title) |
| { |
| dom_exception exc = DOM_NO_ERR; |
| *title = NULL; |
| if (doc->title != NULL) { |
| *title = dom_string_ref(doc->title); |
| } else { |
| dom_element *node; |
| dom_nodelist *nodes; |
| uint32_t len; |
| exc = dom_document_get_elements_by_tag_name(doc, |
| doc->memoised[hds_TITLE], |
| &nodes); |
| if (exc != DOM_NO_ERR) { |
| return exc; |
| } |
| exc = dom_nodelist_get_length(nodes, &len); |
| if (exc != DOM_NO_ERR) { |
| dom_nodelist_unref(nodes); |
| return exc; |
| } |
| if (len == 0) { |
| dom_nodelist_unref(nodes); |
| return DOM_NO_ERR; |
| } |
| exc = dom_nodelist_item(nodes, 0, (void *) &node); |
| dom_nodelist_unref(nodes); |
| if (exc != DOM_NO_ERR) { |
| return exc; |
| } |
| exc = dom_node_get_text_content(node, title); |
| dom_node_unref(node); |
| } |
| return exc; |
| } |
| dom_exception _dom_html_document_set_title(dom_html_document *doc, |
| dom_string *title) |
| { |
| if (doc->title != NULL) |
| dom_string_unref(doc->title); |
| doc->title = dom_string_ref(title); |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_html_document_get_referrer(dom_html_document *doc, |
| dom_string **referrer) |
| { |
| *referrer = dom_string_ref(doc->referrer); |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_html_document_get_domain(dom_html_document *doc, |
| dom_string **domain) |
| { |
| *domain = dom_string_ref(doc->domain); |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_html_document_get_url(dom_html_document *doc, |
| dom_string **url) |
| { |
| *url = dom_string_ref(doc->url); |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_html_document_get_body(dom_html_document *doc, |
| struct dom_html_element **body) |
| { |
| UNUSED(doc); |
| UNUSED(body); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_set_body(dom_html_document *doc, |
| struct dom_html_element *body) |
| { |
| UNUSED(doc); |
| UNUSED(body); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_get_images(dom_html_document *doc, |
| struct dom_html_collection **col) |
| { |
| UNUSED(doc); |
| UNUSED(col); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_get_applets(dom_html_document *doc, |
| struct dom_html_collection **col) |
| { |
| UNUSED(doc); |
| UNUSED(col); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_get_links(dom_html_document *doc, |
| struct dom_html_collection **col) |
| { |
| UNUSED(doc); |
| UNUSED(col); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| static bool __dom_html_document_node_is_form(dom_node_internal *node, |
| void *ctx) |
| { |
| dom_html_document *doc = (dom_html_document *)node->owner; |
| UNUSED(ctx); |
| return dom_string_caseless_isequal(node->name, |
| doc->memoised[hds_FORM]); |
| } |
| dom_exception _dom_html_document_get_forms(dom_html_document *doc, |
| struct dom_html_collection **col) |
| { |
| dom_html_collection *result; |
| dom_element *root; |
| dom_exception err; |
| err = dom_document_get_document_element(doc, &root); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_html_collection_create(doc, (dom_node_internal *) root, |
| __dom_html_document_node_is_form, NULL, &result); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(root); |
| return err; |
| } |
| dom_node_unref(root); |
| *col = result; |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_html_document_get_anchors(dom_html_document *doc, |
| struct dom_html_collection **col) |
| { |
| UNUSED(doc); |
| UNUSED(col); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_get_cookie(dom_html_document *doc, |
| dom_string **cookie) |
| { |
| UNUSED(doc); |
| UNUSED(cookie); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_set_cookie(dom_html_document *doc, |
| dom_string *cookie) |
| { |
| UNUSED(doc); |
| UNUSED(cookie); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_open(dom_html_document *doc) |
| { |
| UNUSED(doc); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_close(dom_html_document *doc) |
| { |
| UNUSED(doc); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_write(dom_html_document *doc, |
| dom_string *text) |
| { |
| UNUSED(doc); |
| UNUSED(text); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_writeln(dom_html_document *doc, |
| dom_string *text) |
| { |
| UNUSED(doc); |
| UNUSED(text); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception _dom_html_document_get_elements_by_name(dom_html_document *doc, |
| dom_string *name, struct dom_nodelist **list) |
| { |
| UNUSED(doc); |
| UNUSED(name); |
| UNUSED(list); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/html/html_document.h |
|---|
| 0,0 → 1,166 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_html_document_h_ |
| #define dom_internal_html_document_h_ |
| #include <dom/html/html_document.h> |
| #include "core/document.h" |
| /** |
| * The dom_html_document class |
| */ |
| struct dom_html_document { |
| struct dom_document base; /**< The base class */ |
| dom_string *title; /**< HTML document title */ |
| dom_string *referrer; /**< HTML document referrer */ |
| dom_string *domain; /**< HTML document domain */ |
| dom_string *url; /**< HTML document URL */ |
| dom_string *cookie; /**< HTML document cookie */ |
| /** Cached strings for html objects to use */ |
| dom_string **memoised; |
| }; |
| #include "html_document_strings.h" |
| /* Create a HTMLDocument */ |
| dom_exception _dom_html_document_create( |
| dom_events_default_action_fetcher daf, |
| void *daf_ctx, |
| dom_html_document **doc); |
| /* Initialise a HTMLDocument */ |
| dom_exception _dom_html_document_initialise( |
| dom_html_document *doc, |
| dom_events_default_action_fetcher daf, |
| void *daf_ctx); |
| /* Finalise a HTMLDocument */ |
| bool _dom_html_document_finalise(dom_html_document *doc); |
| void _dom_html_document_destroy(dom_node_internal *node); |
| dom_exception _dom_html_document_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_DOCUMENT_PROTECT_VTABLE \ |
| _dom_html_document_destroy, \ |
| _dom_html_document_copy |
| dom_exception _dom_html_document_get_title(dom_html_document *doc, |
| dom_string **title); |
| dom_exception _dom_html_document_set_title(dom_html_document *doc, |
| dom_string *title); |
| dom_exception _dom_html_document_get_referrer(dom_html_document *doc, |
| dom_string **referrer); |
| dom_exception _dom_html_document_get_domain(dom_html_document *doc, |
| dom_string **domain); |
| dom_exception _dom_html_document_get_url(dom_html_document *doc, |
| dom_string **url); |
| dom_exception _dom_html_document_get_body(dom_html_document *doc, |
| struct dom_html_element **body); |
| dom_exception _dom_html_document_set_body(dom_html_document *doc, |
| struct dom_html_element *body); |
| dom_exception _dom_html_document_get_images(dom_html_document *doc, |
| struct dom_html_collection **col); |
| dom_exception _dom_html_document_get_applets(dom_html_document *doc, |
| struct dom_html_collection **col); |
| dom_exception _dom_html_document_get_links(dom_html_document *doc, |
| struct dom_html_collection **col); |
| dom_exception _dom_html_document_get_forms(dom_html_document *doc, |
| struct dom_html_collection **col); |
| dom_exception _dom_html_document_get_anchors(dom_html_document *doc, |
| struct dom_html_collection **col); |
| dom_exception _dom_html_document_get_cookie(dom_html_document *doc, |
| dom_string **cookie); |
| dom_exception _dom_html_document_set_cookie(dom_html_document *doc, |
| dom_string *cookie); |
| dom_exception _dom_html_document_open(dom_html_document *doc); |
| dom_exception _dom_html_document_close(dom_html_document *doc); |
| dom_exception _dom_html_document_write(dom_html_document *doc, |
| dom_string *text); |
| dom_exception _dom_html_document_writeln(dom_html_document *doc, |
| dom_string *text); |
| dom_exception _dom_html_document_get_elements_by_name(dom_html_document *doc, |
| dom_string *name, struct dom_nodelist **list); |
| #define DOM_HTML_DOCUMENT_VTABLE \ |
| _dom_html_document_get_title, \ |
| _dom_html_document_set_title, \ |
| _dom_html_document_get_referrer, \ |
| _dom_html_document_get_domain, \ |
| _dom_html_document_get_url, \ |
| _dom_html_document_get_body, \ |
| _dom_html_document_set_body, \ |
| _dom_html_document_get_images, \ |
| _dom_html_document_get_applets, \ |
| _dom_html_document_get_links, \ |
| _dom_html_document_get_forms, \ |
| _dom_html_document_get_anchors, \ |
| _dom_html_document_get_cookie, \ |
| _dom_html_document_set_cookie, \ |
| _dom_html_document_open, \ |
| _dom_html_document_close, \ |
| _dom_html_document_write, \ |
| _dom_html_document_writeln, \ |
| _dom_html_document_get_elements_by_name |
| dom_exception _dom_html_document_create_element(dom_document *doc, |
| dom_string *tag_name, dom_element **result); |
| dom_exception _dom_html_document_create_element_ns(dom_document *doc, |
| dom_string *namespace, dom_string *qname, |
| dom_element **result); |
| dom_exception _dom_html_document_get_elements_by_tag_name(dom_document *doc, |
| dom_string *tagname, dom_nodelist **result); |
| dom_exception _dom_html_document_get_elements_by_tag_name_ns( |
| dom_document *doc, dom_string *namespace, |
| dom_string *localname, dom_nodelist **result); |
| dom_exception _dom_html_document_create_attribute(dom_document *doc, |
| dom_string *name, dom_attr **result); |
| dom_exception _dom_html_document_create_attribute_ns(dom_document *doc, |
| dom_string *namespace, dom_string *qname, |
| dom_attr **result); |
| #define DOM_DOCUMENT_VTABLE_HTML \ |
| _dom_document_get_doctype, \ |
| _dom_document_get_implementation, \ |
| _dom_document_get_document_element, \ |
| _dom_html_document_create_element, \ |
| _dom_document_create_document_fragment, \ |
| _dom_document_create_text_node, \ |
| _dom_document_create_comment, \ |
| _dom_document_create_cdata_section, \ |
| _dom_document_create_processing_instruction, \ |
| _dom_html_document_create_attribute, \ |
| _dom_document_create_entity_reference, \ |
| _dom_html_document_get_elements_by_tag_name, \ |
| _dom_document_import_node, \ |
| _dom_html_document_create_element_ns, \ |
| _dom_html_document_create_attribute_ns, \ |
| _dom_html_document_get_elements_by_tag_name_ns, \ |
| _dom_document_get_element_by_id, \ |
| _dom_document_get_input_encoding, \ |
| _dom_document_get_xml_encoding, \ |
| _dom_document_get_xml_standalone, \ |
| _dom_document_set_xml_standalone, \ |
| _dom_document_get_xml_version, \ |
| _dom_document_set_xml_version, \ |
| _dom_document_get_strict_error_checking, \ |
| _dom_document_set_strict_error_checking, \ |
| _dom_document_get_uri, \ |
| _dom_document_set_uri, \ |
| _dom_document_adopt_node, \ |
| _dom_document_get_dom_config, \ |
| _dom_document_normalize, \ |
| _dom_document_rename_node, \ |
| _dom_document_get_quirks_mode, \ |
| _dom_document_set_quirks_mode |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_document_strings.h |
|---|
| 0,0 → 1,181 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| /* Note, this file deliberately lacks guards since it's included many times |
| * in many places in order to correctly handle the loading of the strings. |
| */ |
| #ifndef HTML_DOCUMENT_STRINGS_ACTION |
| #define HTML_DOCUMENT_STRINGS_INTERNAL_ACTION 1 |
| #define HTML_DOCUMENT_STRINGS_PREFIX \ |
| typedef enum { |
| #define HTML_DOCUMENT_STRINGS_SUFFIX \ |
| hds_COUNT \ |
| } html_document_memo_string_e; |
| #define HTML_DOCUMENT_STRINGS_ACTION(tag,str) \ |
| hds_##tag, |
| #endif |
| #define HTML_DOCUMENT_STRINGS_ACTION1(x) HTML_DOCUMENT_STRINGS_ACTION(x,x) |
| #ifdef HTML_DOCUMENT_STRINGS_PREFIX |
| HTML_DOCUMENT_STRINGS_PREFIX |
| #endif |
| /* Useful attributes for HTMLElement */ |
| HTML_DOCUMENT_STRINGS_ACTION1(id) |
| HTML_DOCUMENT_STRINGS_ACTION1(title) |
| HTML_DOCUMENT_STRINGS_ACTION1(lang) |
| HTML_DOCUMENT_STRINGS_ACTION1(dir) |
| HTML_DOCUMENT_STRINGS_ACTION1(class) |
| /* Useful attributes used by HTMLHtmlElement */ |
| HTML_DOCUMENT_STRINGS_ACTION1(version) |
| /* Useful attributes used by HTMLHeadElement */ |
| HTML_DOCUMENT_STRINGS_ACTION1(profile) |
| /* Useful attributes used by HTMLLinkElement */ |
| HTML_DOCUMENT_STRINGS_ACTION1(charset) |
| HTML_DOCUMENT_STRINGS_ACTION1(href) |
| HTML_DOCUMENT_STRINGS_ACTION1(hreflang) |
| HTML_DOCUMENT_STRINGS_ACTION1(media) |
| HTML_DOCUMENT_STRINGS_ACTION1(rel) |
| HTML_DOCUMENT_STRINGS_ACTION1(rev) |
| HTML_DOCUMENT_STRINGS_ACTION1(target) |
| HTML_DOCUMENT_STRINGS_ACTION1(type) |
| /* Useful attributes used by HTMLMetaElement */ |
| HTML_DOCUMENT_STRINGS_ACTION1(content) |
| HTML_DOCUMENT_STRINGS_ACTION(http_equiv,http-equiv) |
| HTML_DOCUMENT_STRINGS_ACTION1(name) |
| HTML_DOCUMENT_STRINGS_ACTION1(scheme) |
| /* HTMLBodyElement attributes */ |
| HTML_DOCUMENT_STRINGS_ACTION(a_link,alink) |
| HTML_DOCUMENT_STRINGS_ACTION(v_link,vlink) |
| HTML_DOCUMENT_STRINGS_ACTION(bg_color,bgcolor) |
| HTML_DOCUMENT_STRINGS_ACTION1(background) |
| HTML_DOCUMENT_STRINGS_ACTION1(link) |
| HTML_DOCUMENT_STRINGS_ACTION1(text) |
| /* Useful attributes used by HTMLFormElement */ |
| HTML_DOCUMENT_STRINGS_ACTION(accept_charset,accept-charset) |
| HTML_DOCUMENT_STRINGS_ACTION1(action) |
| HTML_DOCUMENT_STRINGS_ACTION1(enctype) |
| HTML_DOCUMENT_STRINGS_ACTION1(method) |
| /* HTML_DOCUMENT_STRINGS_ACTION1(target) */ |
| /* Useful attributes used by HTMLButtonElement */ |
| HTML_DOCUMENT_STRINGS_ACTION(access_key,accesskey) |
| /* HTML_DOCUMENT_STRINGS_ACTION1(name) */ |
| /* HTML_DOCUMENT_STRINGS_ACTION1(type) */ |
| HTML_DOCUMENT_STRINGS_ACTION1(value) |
| /* Useful attributes used by HTMLInputElement */ |
| HTML_DOCUMENT_STRINGS_ACTION1(accept) |
| /* HTML_DOCUMENT_STRINGS_ACTION(access_key,accesskey) */ |
| HTML_DOCUMENT_STRINGS_ACTION1(align) |
| HTML_DOCUMENT_STRINGS_ACTION1(alt) |
| HTML_DOCUMENT_STRINGS_ACTION1(checked) |
| HTML_DOCUMENT_STRINGS_ACTION1(disabled) |
| HTML_DOCUMENT_STRINGS_ACTION(max_length,maxlength) |
| /* HTML_DOCUMENT_STRINGS_ACTION1(name) */ |
| HTML_DOCUMENT_STRINGS_ACTION(read_only,readonly) |
| HTML_DOCUMENT_STRINGS_ACTION1(size) |
| HTML_DOCUMENT_STRINGS_ACTION1(src) |
| HTML_DOCUMENT_STRINGS_ACTION(tab_index,tabindex) |
| /* HTML_DOCUMENT_STRINGS_ACTION1(type) */ |
| HTML_DOCUMENT_STRINGS_ACTION(use_map,usemap) |
| /* HTML_DOCUMENT_STRINGS_ACTION1(value) */ |
| /* HTMLTextAreaElement type */ |
| HTML_DOCUMENT_STRINGS_ACTION1(textarea) |
| /* HTMLOptGroupElement attributes */ |
| HTML_DOCUMENT_STRINGS_ACTION1(label) |
| /* HTMLOptionElement attributes */ |
| /* HTML_DOCUMENT_STRINGS_ACTION1(label) */ |
| HTML_DOCUMENT_STRINGS_ACTION1(selected) |
| /* HTML_DOCUMENT_STRINGS_ACTION1(value) */ |
| /* HTMLSelectElement strings */ |
| HTML_DOCUMENT_STRINGS_ACTION(select_multiple,select-multiple) |
| HTML_DOCUMENT_STRINGS_ACTION(select_one,select-one) |
| /* Some event strings for later */ |
| HTML_DOCUMENT_STRINGS_ACTION1(blur) |
| HTML_DOCUMENT_STRINGS_ACTION1(focus) |
| HTML_DOCUMENT_STRINGS_ACTION1(select) |
| HTML_DOCUMENT_STRINGS_ACTION1(click) |
| HTML_DOCUMENT_STRINGS_ACTION1(submit) |
| HTML_DOCUMENT_STRINGS_ACTION1(reset) |
| /* Names for elements which get specialised. */ |
| HTML_DOCUMENT_STRINGS_ACTION1(HTML) |
| HTML_DOCUMENT_STRINGS_ACTION1(HEAD) |
| HTML_DOCUMENT_STRINGS_ACTION1(LINK) |
| HTML_DOCUMENT_STRINGS_ACTION1(TITLE) |
| HTML_DOCUMENT_STRINGS_ACTION1(META) |
| HTML_DOCUMENT_STRINGS_ACTION1(BASE) |
| HTML_DOCUMENT_STRINGS_ACTION1(ISINDEX) |
| HTML_DOCUMENT_STRINGS_ACTION1(STYLE) |
| HTML_DOCUMENT_STRINGS_ACTION1(BODY) |
| HTML_DOCUMENT_STRINGS_ACTION1(FORM) |
| HTML_DOCUMENT_STRINGS_ACTION1(SELECT) |
| HTML_DOCUMENT_STRINGS_ACTION1(OPTGROUP) |
| HTML_DOCUMENT_STRINGS_ACTION1(OPTION) |
| HTML_DOCUMENT_STRINGS_ACTION1(INPUT) |
| HTML_DOCUMENT_STRINGS_ACTION1(TEXTAREA) |
| HTML_DOCUMENT_STRINGS_ACTION1(BUTTON) |
| HTML_DOCUMENT_STRINGS_ACTION1(LABEL) |
| HTML_DOCUMENT_STRINGS_ACTION1(FIELDSET) |
| HTML_DOCUMENT_STRINGS_ACTION1(LEGEND) |
| HTML_DOCUMENT_STRINGS_ACTION1(UL) |
| HTML_DOCUMENT_STRINGS_ACTION1(OL) |
| HTML_DOCUMENT_STRINGS_ACTION1(DL) |
| HTML_DOCUMENT_STRINGS_ACTION1(DIR) |
| HTML_DOCUMENT_STRINGS_ACTION1(MENU) |
| HTML_DOCUMENT_STRINGS_ACTION1(LI) |
| HTML_DOCUMENT_STRINGS_ACTION1(BLOCKQUOTE) |
| HTML_DOCUMENT_STRINGS_ACTION1(DIV) |
| HTML_DOCUMENT_STRINGS_ACTION1(P) |
| HTML_DOCUMENT_STRINGS_ACTION1(H1) |
| HTML_DOCUMENT_STRINGS_ACTION1(H2) |
| HTML_DOCUMENT_STRINGS_ACTION1(H3) |
| HTML_DOCUMENT_STRINGS_ACTION1(H4) |
| HTML_DOCUMENT_STRINGS_ACTION1(H5) |
| HTML_DOCUMENT_STRINGS_ACTION1(H6) |
| HTML_DOCUMENT_STRINGS_ACTION1(Q) |
| HTML_DOCUMENT_STRINGS_ACTION1(PRE) |
| HTML_DOCUMENT_STRINGS_ACTION1(BR) |
| HTML_DOCUMENT_STRINGS_ACTION1(BASEFONT) |
| HTML_DOCUMENT_STRINGS_ACTION1(FONT) |
| HTML_DOCUMENT_STRINGS_ACTION1(HR) |
| HTML_DOCUMENT_STRINGS_ACTION1(INS) |
| HTML_DOCUMENT_STRINGS_ACTION1(DEL) |
| HTML_DOCUMENT_STRINGS_ACTION1(A) |
| HTML_DOCUMENT_STRINGS_ACTION1(IMG) |
| HTML_DOCUMENT_STRINGS_ACTION1(OBJECT) |
| HTML_DOCUMENT_STRINGS_ACTION1(PARAM) |
| HTML_DOCUMENT_STRINGS_ACTION1(APPLET) |
| HTML_DOCUMENT_STRINGS_ACTION1(MAP) |
| HTML_DOCUMENT_STRINGS_ACTION1(AREA) |
| HTML_DOCUMENT_STRINGS_ACTION1(SCRIPT) |
| HTML_DOCUMENT_STRINGS_ACTION1(TABLE) |
| HTML_DOCUMENT_STRINGS_ACTION1(CAPTION) |
| HTML_DOCUMENT_STRINGS_ACTION1(COL) |
| HTML_DOCUMENT_STRINGS_ACTION1(COLGROUP) |
| HTML_DOCUMENT_STRINGS_ACTION1(THEAD) |
| HTML_DOCUMENT_STRINGS_ACTION1(TFOOT) |
| HTML_DOCUMENT_STRINGS_ACTION1(TBODY) |
| HTML_DOCUMENT_STRINGS_ACTION1(TR) |
| HTML_DOCUMENT_STRINGS_ACTION1(TH) |
| HTML_DOCUMENT_STRINGS_ACTION1(TD) |
| HTML_DOCUMENT_STRINGS_ACTION1(FRAMESET) |
| HTML_DOCUMENT_STRINGS_ACTION1(FRAME) |
| HTML_DOCUMENT_STRINGS_ACTION1(IFRAME) |
| #ifdef HTML_DOCUMENT_STRINGS_SUFFIX |
| HTML_DOCUMENT_STRINGS_SUFFIX |
| #endif |
| #undef HTML_DOCUMENT_STRINGS_ACTION1 |
| #ifdef HTML_DOCUMENT_STRINGS_INTERNAL_ACTION |
| #undef HTML_DOCUMENT_STRINGS_INTERNAL_ACTION |
| #undef HTML_DOCUMENT_STRINGS_PREFIX |
| #undef HTML_DOCUMENT_STRINGS_SUFFIX |
| #undef HTML_DOCUMENT_STRINGS_ACTION |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_element.c |
|---|
| 0,0 → 1,414 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <stdio.h> |
| #include "html/html_document.h" |
| #include "html/html_element.h" |
| #include "core/node.h" |
| #include "core/attr.h" |
| #include "core/document.h" |
| #include "utils/utils.h" |
| struct dom_html_element_vtable _dom_html_element_vtable = { |
| { |
| { |
| { |
| DOM_NODE_EVENT_TARGET_VTABLE |
| }, |
| DOM_NODE_VTABLE_ELEMENT, |
| }, |
| DOM_ELEMENT_VTABLE_HTML_ELEMENT, |
| }, |
| DOM_HTML_ELEMENT_VTABLE |
| }; |
| static struct dom_element_protected_vtable _dom_html_element_protect_vtable = { |
| { |
| DOM_HTML_ELEMENT_PROTECT_VTABLE |
| }, |
| DOM_ELEMENT_PROTECT_VTABLE |
| }; |
| dom_exception _dom_html_element_create(struct dom_html_document *doc, |
| dom_string *name, dom_string *namespace, |
| dom_string *prefix, struct dom_html_element **result) |
| { |
| dom_exception error; |
| dom_html_element *el; |
| el = malloc(sizeof(struct dom_html_element)); |
| if (el == NULL) |
| return DOM_NO_MEM_ERR; |
| el->base.base.base.vtable = &_dom_html_element_vtable; |
| el->base.base.vtable = &_dom_html_element_protect_vtable; |
| error = _dom_html_element_initialise(doc, el, name, namespace, |
| prefix); |
| if (error != DOM_NO_ERR) { |
| free(el); |
| return error; |
| } |
| *result = el; |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_html_element_initialise(struct dom_html_document *doc, |
| struct dom_html_element *el, dom_string *name, |
| dom_string *namespace, dom_string *prefix) |
| { |
| dom_exception err; |
| err = _dom_element_initialise(&doc->base, &el->base, name, namespace, prefix); |
| if (err != DOM_NO_ERR) |
| return err; |
| return err; |
| } |
| void _dom_html_element_finalise(struct dom_html_element *ele) |
| { |
| _dom_element_finalise(&ele->base); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_html_element_destroy(dom_node_internal *node) |
| { |
| dom_html_element *html = (dom_html_element *) node; |
| _dom_html_element_finalise(html); |
| free(html); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* API functions */ |
| #define SIMPLE_GET_SET(fattr,attr) \ |
| dom_exception _dom_html_element_get_##fattr(dom_html_element *element, \ |
| dom_string **fattr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_get_attribute(element, _memo_##attr, fattr); \ |
| \ |
| return ret; \ |
| } \ |
| \ |
| dom_exception _dom_html_element_set_##fattr(dom_html_element *element, \ |
| dom_string *fattr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_set_attribute(element, _memo_##attr, fattr); \ |
| \ |
| return ret; \ |
| } |
| SIMPLE_GET_SET(id,id) |
| SIMPLE_GET_SET(title,title) |
| SIMPLE_GET_SET(lang,lang) |
| SIMPLE_GET_SET(dir,dir) |
| SIMPLE_GET_SET(class_name,class) |
| /** |
| * Retrieve a list of descendant elements of an element which match a given |
| * tag name (caselessly) |
| * |
| * \param element The root of the subtree to search |
| * \param name The tag name to match (or "*" for all tags) |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR. |
| * |
| * The returned nodelist will have its reference count increased. It is |
| * the responsibility of the caller to unref the nodelist once it has |
| * finished with it. |
| */ |
| dom_exception _dom_html_element_get_elements_by_tag_name( |
| struct dom_element *element, dom_string *name, |
| struct dom_nodelist **result) |
| { |
| dom_exception err; |
| dom_node_internal *base = (dom_node_internal *) element; |
| assert(base->owner != NULL); |
| err = _dom_document_get_nodelist(base->owner, |
| DOM_NODELIST_BY_NAME_CASELESS, |
| (struct dom_node_internal *) element, name, NULL, |
| NULL, result); |
| return err; |
| } |
| /** |
| * Retrieve a list of descendant elements of an element which match a given |
| * namespace/localname pair, caselessly. |
| * |
| * \param element The root of the subtree to search |
| * \param namespace The namespace URI to match (or "*" for all) |
| * \param localname The local name to match (or "*" for all) |
| * \param result Pointer to location to receive result |
| * \return DOM_NO_ERR on success, |
| * DOM_NOT_SUPPORTED_ERR if the implementation does not support |
| * the feature "XML" and the language exposed |
| * through the Document does not support |
| * Namespaces. |
| * |
| * The returned nodelist will have its reference count increased. It is |
| * the responsibility of the caller to unref the nodelist once it has |
| * finished with it. |
| */ |
| dom_exception _dom_html_element_get_elements_by_tag_name_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *localname, struct dom_nodelist **result) |
| { |
| dom_exception err; |
| /** \todo ensure XML feature is supported */ |
| err = _dom_document_get_nodelist(element->base.owner, |
| DOM_NODELIST_BY_NAMESPACE_CASELESS, |
| (struct dom_node_internal *) element, NULL, |
| namespace, localname, |
| result); |
| return err; |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Common functions */ |
| /** |
| * Get the a bool property |
| * |
| * \param ele The dom_html_element object |
| * \param name The name of the attribute |
| * \param len The length of ::name |
| * \param has The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_element_get_bool_property(dom_html_element *ele, |
| const char *name, uint32_t len, bool *has) |
| { |
| dom_string *str = NULL; |
| dom_attr *a = NULL; |
| dom_exception err; |
| err = dom_string_create((const uint8_t *) name, len, &str); |
| if (err != DOM_NO_ERR) |
| goto fail; |
| err = dom_element_get_attribute_node(ele, str, &a); |
| if (err != DOM_NO_ERR) |
| goto cleanup1; |
| if (a != NULL) { |
| *has = true; |
| } else { |
| *has = false; |
| } |
| dom_node_unref(a); |
| cleanup1: |
| dom_string_unref(str); |
| fail: |
| return err; |
| } |
| /** |
| * Set a bool property |
| * |
| * \param ele The dom_html_element object |
| * \param name The name of the attribute |
| * \param len The length of ::name |
| * \param has The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_element_set_bool_property(dom_html_element *ele, |
| const char *name, uint32_t len, bool has) |
| { |
| dom_string *str = NULL; |
| dom_attr *a = NULL; |
| dom_exception err; |
| err = dom_string_create((const uint8_t *) name, len, &str); |
| if (err != DOM_NO_ERR) |
| goto fail; |
| err = dom_element_get_attribute_node(ele, str, &a); |
| if (err != DOM_NO_ERR) |
| goto cleanup1; |
| if (a != NULL && has == false) { |
| dom_attr *res = NULL; |
| err = dom_element_remove_attribute_node(ele, a, &res); |
| if (err != DOM_NO_ERR) |
| goto cleanup2; |
| dom_node_unref(res); |
| } else if (a == NULL && has == true) { |
| dom_document *doc = dom_node_get_owner(ele); |
| dom_attr *res = NULL; |
| err = _dom_attr_create(doc, str, NULL, NULL, true, &a); |
| if (err != DOM_NO_ERR) { |
| goto cleanup1; |
| } |
| err = dom_element_set_attribute_node(ele, a, &res); |
| if (err != DOM_NO_ERR) |
| goto cleanup2; |
| dom_node_unref(res); |
| } |
| cleanup2: |
| dom_node_unref(a); |
| cleanup1: |
| dom_string_unref(str); |
| fail: |
| return err; |
| } |
| static char *_strndup(const char *s, size_t n) |
| { |
| size_t len; |
| char *s2; |
| for (len = 0; len != n && s[len] != '\0'; len++) |
| continue; |
| s2 = malloc(len + 1); |
| if (s2 == NULL) |
| return NULL; |
| memcpy(s2, s, len); |
| s2[len] = '\0'; |
| return s2; |
| } |
| /** |
| * Get the a int32_t property |
| * |
| * \param ele The dom_html_element object |
| * \param name The name of the attribute |
| * \param len The length of ::name |
| * \param value The returned value, or -1 if prop. not set |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_element_get_int32_t_property(dom_html_element *ele, |
| const char *name, uint32_t len, int32_t *value) |
| { |
| dom_string *str = NULL, *s2 = NULL; |
| dom_attr *a = NULL; |
| dom_exception err; |
| err = dom_string_create((const uint8_t *) name, len, &str); |
| if (err != DOM_NO_ERR) |
| goto fail; |
| err = dom_element_get_attribute_node(ele, str, &a); |
| if (err != DOM_NO_ERR) |
| goto cleanup1; |
| if (a != NULL) { |
| err = dom_node_get_text_content(a, &s2); |
| if (err == DOM_NO_ERR) { |
| char *s3 = _strndup(dom_string_data(s2), |
| dom_string_byte_length(s2)); |
| if (s3 != NULL) { |
| *value = strtoul(s3, NULL, 0); |
| free(s3); |
| } else { |
| err = DOM_NO_MEM_ERR; |
| } |
| dom_string_unref(s2); |
| } |
| } else { |
| /* Property is not set on this node */ |
| *value = -1; |
| } |
| dom_node_unref(a); |
| cleanup1: |
| dom_string_unref(str); |
| fail: |
| return err; |
| } |
| /** |
| * Set a int32_t property |
| * |
| * \param ele The dom_html_element object |
| * \param name The name of the attribute |
| * \param len The length of ::name |
| * \param value The value |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_element_set_int32_t_property(dom_html_element *ele, |
| const char *name, uint32_t len, uint32_t value) |
| { |
| dom_string *str = NULL, *svalue = NULL; |
| dom_exception err; |
| char numbuffer[32]; |
| err = dom_string_create((const uint8_t *) name, len, &str); |
| if (err != DOM_NO_ERR) |
| goto fail; |
| if (snprintf(numbuffer, 32, "%u", value) == 32) |
| numbuffer[31] = '\0'; |
| err = dom_string_create((const uint8_t *) numbuffer, |
| strlen(numbuffer), &svalue); |
| if (err != DOM_NO_ERR) |
| goto cleanup; |
| err = dom_element_set_attribute(ele, svalue, str); |
| dom_string_unref(svalue); |
| cleanup: |
| dom_string_unref(str); |
| fail: |
| return err; |
| } |
| /contrib/network/netsurf/libdom/src/html/html_element.h |
|---|
| 0,0 → 1,128 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_html_element_h_ |
| #define dom_internal_html_element_h_ |
| #include <dom/html/html_element.h> |
| #include "core/element.h" |
| struct dom_html_document; |
| /** |
| * The dom_html_element class |
| * |
| */ |
| struct dom_html_element { |
| struct dom_element base; |
| /**< The base class */ |
| }; |
| dom_exception _dom_html_element_create(struct dom_html_document *doc, |
| dom_string *name, dom_string *namespace, |
| dom_string *prefix, dom_html_element **result); |
| dom_exception _dom_html_element_initialise(struct dom_html_document *doc, |
| struct dom_html_element *el, dom_string *name, |
| dom_string *namespace, dom_string *prefix); |
| void _dom_html_element_finalise(struct dom_html_element *ele); |
| /* Virtual functions */ |
| dom_exception _dom_html_element_get_elements_by_tag_name( |
| struct dom_element *element, dom_string *name, |
| struct dom_nodelist **result); |
| dom_exception _dom_html_element_get_elements_by_tag_name_ns( |
| struct dom_element *element, dom_string *namespace, |
| dom_string *localname, struct dom_nodelist **result); |
| /* The protected virtual functions */ |
| void _dom_html_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_ELEMENT_VTABLE_HTML_ELEMENT \ |
| _dom_element_get_tag_name, \ |
| _dom_element_get_attribute, \ |
| _dom_element_set_attribute, \ |
| _dom_element_remove_attribute, \ |
| _dom_element_get_attribute_node, \ |
| _dom_element_set_attribute_node, \ |
| _dom_element_remove_attribute_node, \ |
| _dom_html_element_get_elements_by_tag_name, \ |
| _dom_element_get_attribute_ns, \ |
| _dom_element_set_attribute_ns, \ |
| _dom_element_remove_attribute_ns, \ |
| _dom_element_get_attribute_node_ns, \ |
| _dom_element_set_attribute_node_ns, \ |
| _dom_html_element_get_elements_by_tag_name_ns, \ |
| _dom_element_has_attribute, \ |
| _dom_element_has_attribute_ns, \ |
| _dom_element_get_schema_type_info, \ |
| _dom_element_set_id_attribute, \ |
| _dom_element_set_id_attribute_ns, \ |
| _dom_element_set_id_attribute_node, \ |
| _dom_element_get_classes, \ |
| _dom_element_has_class |
| #define DOM_HTML_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_element_destroy, \ |
| _dom_html_element_copy |
| /* The API functions */ |
| dom_exception _dom_html_element_get_id(dom_html_element *element, |
| dom_string **id); |
| dom_exception _dom_html_element_set_id(dom_html_element *element, |
| dom_string *id); |
| dom_exception _dom_html_element_get_title(dom_html_element *element, |
| dom_string **title); |
| dom_exception _dom_html_element_set_title(dom_html_element *element, |
| dom_string *title); |
| dom_exception _dom_html_element_get_lang(dom_html_element *element, |
| dom_string **lang); |
| dom_exception _dom_html_element_set_lang(dom_html_element *element, |
| dom_string *lang); |
| dom_exception _dom_html_element_get_dir(dom_html_element *element, |
| dom_string **dir); |
| dom_exception _dom_html_element_set_dir(dom_html_element *element, |
| dom_string *dir); |
| dom_exception _dom_html_element_get_class_name(dom_html_element *element, |
| dom_string **class_name); |
| dom_exception _dom_html_element_set_class_name(dom_html_element *element, |
| dom_string *class_name); |
| #define DOM_HTML_ELEMENT_VTABLE \ |
| _dom_html_element_get_id, \ |
| _dom_html_element_set_id, \ |
| _dom_html_element_get_title, \ |
| _dom_html_element_set_title, \ |
| _dom_html_element_get_lang, \ |
| _dom_html_element_set_lang, \ |
| _dom_html_element_get_dir, \ |
| _dom_html_element_set_dir, \ |
| _dom_html_element_get_class_name, \ |
| _dom_html_element_set_class_name |
| /* Some common functions used by all child classes */ |
| dom_exception dom_html_element_get_bool_property(dom_html_element *ele, |
| const char *name, uint32_t len, bool *has); |
| dom_exception dom_html_element_set_bool_property(dom_html_element *ele, |
| const char *name, uint32_t len, bool has); |
| dom_exception dom_html_element_get_int32_t_property(dom_html_element *ele, |
| const char *name, uint32_t len, int32_t *value); |
| dom_exception dom_html_element_set_int32_t_property(dom_html_element *ele, |
| const char *name, uint32_t len, uint32_t value); |
| extern struct dom_html_element_vtable _dom_html_element_vtable; |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_fieldset_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_fieldset_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_font_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_font_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_form_element.c |
|---|
| 0,0 → 1,313 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/html/html_form_element.h> |
| #include "html/html_form_element.h" |
| #include "html/html_button_element.h" |
| #include "html/html_collection.h" |
| #include "html/html_document.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_FORM_ELEMENT |
| }, |
| DOM_HTML_FORM_ELEMENT_PROTECT_VTABLE |
| }; |
| static bool _dom_is_form_control(struct dom_node_internal *node, void *ctx); |
| /** |
| * Create a dom_html_form_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_form_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_form_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_form_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_form_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_form_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_form_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_form_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_form_element *ele) |
| { |
| dom_exception err; |
| err = _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_FORM], |
| namespace, prefix); |
| ele->col = NULL; |
| return err; |
| } |
| /** |
| * Finalise a dom_html_form_element object |
| * |
| * \param ele The dom_html_form_element object |
| */ |
| void _dom_html_form_element_finalise(struct dom_html_form_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_form_element object |
| * |
| * \param ele The dom_html_form_element object |
| */ |
| void _dom_html_form_element_destroy(struct dom_html_form_element *ele) |
| { |
| _dom_html_form_element_finalise(ele); |
| free(ele); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_form_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_form_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_form_element_destroy((struct dom_html_form_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_form_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| /** |
| * Get the form controls under this form element |
| * |
| * \param ele The form object |
| * \param col The collection of form controls |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_form_element_get_elements(dom_html_form_element *ele, |
| struct dom_html_collection **col) |
| { |
| dom_exception err; |
| if (ele->col == NULL) { |
| dom_html_document *doc = (dom_html_document *) dom_node_get_owner(ele); |
| assert(doc != NULL); |
| err = _dom_html_collection_create(doc, |
| (dom_node_internal *) doc, |
| _dom_is_form_control, ele, col); |
| if (err != DOM_NO_ERR) |
| return err; |
| ele->col = *col; |
| } |
| *col = ele->col; |
| dom_html_collection_ref(*col); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the number of form controls under this form element |
| * |
| * \param ele The form object |
| * \param len The number of controls |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_form_element_get_length(dom_html_form_element *ele, |
| uint32_t *len) |
| { |
| dom_exception err; |
| if (ele->col == NULL) { |
| dom_html_document *doc = (dom_html_document *) dom_node_get_owner(ele); |
| assert(doc != NULL); |
| err = _dom_html_collection_create(doc, |
| (dom_node_internal *) doc, |
| _dom_is_form_control, ele, &ele->col); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| return dom_html_collection_get_length(ele->col, len); |
| } |
| #define SIMPLE_GET_SET(attr) \ |
| dom_exception dom_html_form_element_get_##attr( \ |
| dom_html_form_element *element, \ |
| dom_string **attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_get_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } \ |
| \ |
| dom_exception dom_html_form_element_set_##attr( \ |
| dom_html_form_element *element, \ |
| dom_string *attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_set_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| SIMPLE_GET_SET(accept_charset) |
| SIMPLE_GET_SET(action) |
| SIMPLE_GET_SET(enctype) |
| SIMPLE_GET_SET(method) |
| SIMPLE_GET_SET(target) |
| /** |
| * Submit this form |
| * |
| * \param ele The form object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_form_element_submit(dom_html_form_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /* Dispatch an event and let the default action handler to deal with |
| * the submit action, and a 'submit' event is bubbling and cancelable |
| */ |
| return _dom_dispatch_generic_event((dom_document *)doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_submit], true, |
| true, &success); |
| } |
| /** |
| * Reset this form |
| * |
| * \param ele The form object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_form_element_reset(dom_html_form_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /* Dispatch an event and let the default action handler to deal with |
| * the reset action, and a 'reset' event is bubbling and cancelable |
| */ |
| return _dom_dispatch_generic_event((dom_document *) doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_reset], true, |
| true, &success); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Internal functions */ |
| /* Callback function to test whether certain node is a form control, see |
| * src/html/html_collection.h for detail. */ |
| static bool _dom_is_form_control(struct dom_node_internal *node, void *ctx) |
| { |
| struct dom_html_document *doc = |
| (struct dom_html_document *)(node->owner); |
| struct dom_html_form_element *form = ctx, *form2; |
| assert(node->type == DOM_ELEMENT_NODE); |
| /* Form controls are INPUT TEXTAREA SELECT and BUTTON */ |
| if (dom_string_caseless_isequal(node->name, |
| doc->memoised[hds_INPUT])) |
| return true; |
| if (dom_string_caseless_isequal(node->name, |
| doc->memoised[hds_TEXTAREA])) |
| return true; |
| if (dom_string_caseless_isequal(node->name, |
| doc->memoised[hds_SELECT])) |
| return true; |
| if (dom_string_caseless_isequal(node->name, |
| doc->memoised[hds_BUTTON])) { |
| dom_html_button_element *button = |
| (dom_html_button_element *) node; |
| dom_exception err = |
| dom_html_button_element_get_form(button, &form2); |
| if (err == DOM_NO_ERR) { |
| return form == form2; |
| } |
| /* Couldn't get the form, assume it's not ours. */ |
| return false; |
| } |
| return false; |
| } |
| /contrib/network/netsurf/libdom/src/html/html_form_element.h |
|---|
| 0,0 → 1,56 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_internal_html_form_element_h_ |
| #define dom_internal_html_form_element_h_ |
| #include <dom/html/html_form_element.h> |
| #include "html/html_element.h" |
| struct dom_html_collection; |
| struct dom_html_form_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| struct dom_html_collection *col; |
| /**< The collection of form controls */ |
| }; |
| /* Create a dom_html_form_element object */ |
| dom_exception _dom_html_form_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_form_element **ele); |
| /* Initialise a dom_html_form_element object */ |
| dom_exception _dom_html_form_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_form_element *ele); |
| /* Finalise a dom_html_form_element object */ |
| void _dom_html_form_element_finalise(struct dom_html_form_element *ele); |
| /* Destroy a dom_html_form_element object */ |
| void _dom_html_form_element_destroy(struct dom_html_form_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_form_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_form_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_form_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_FORM_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_form_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_FORM_ELEMENT \ |
| _dom_virtual_html_form_element_destroy, \ |
| _dom_html_form_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_frame_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_frame_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_frameset_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_frameset_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_head_element.c |
|---|
| 0,0 → 1,147 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <stdlib.h> |
| #include "html/html_document.h" |
| #include "html/html_head_element.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_HEAD_ELEMENT |
| }, |
| DOM_HTML_HEAD_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_head_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_head_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_head_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_head_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_head_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_head_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_head_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_head_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_head_element *ele) |
| { |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_HEAD], |
| namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_head_element object |
| * |
| * \param ele The dom_html_head_element object |
| */ |
| void _dom_html_head_element_finalise(struct dom_html_head_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_head_element object |
| * |
| * \param ele The dom_html_head_element object |
| */ |
| void _dom_html_head_element_destroy(struct dom_html_head_element *ele) |
| { |
| _dom_html_head_element_finalise(ele); |
| free(ele); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_head_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_head_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_head_element_destroy((struct dom_html_head_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_head_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* API functions */ |
| dom_exception dom_html_head_element_get_profile(dom_html_head_element *element, |
| dom_string **profile) |
| { |
| dom_exception ret; |
| dom_string *_memo_profile; |
| _memo_profile = |
| ((struct dom_html_document *) |
| ((struct dom_node_internal *)element)->owner)->memoised[hds_profile]; |
| ret = dom_element_get_attribute(element, _memo_profile, profile); |
| return ret; |
| } |
| dom_exception dom_html_head_element_set_profile(dom_html_head_element *element, |
| dom_string *profile) |
| { |
| dom_exception ret; |
| dom_string *_memo_profile; |
| _memo_profile = |
| ((struct dom_html_document *) |
| ((struct dom_node_internal *)element)->owner)->memoised[hds_profile]; |
| ret = dom_element_set_attribute(element, _memo_profile, profile); |
| return ret; |
| } |
| /contrib/network/netsurf/libdom/src/html/html_head_element.h |
|---|
| 0,0 → 1,52 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_internal_html_head_element_h_ |
| #define dom_internal_html_head_element_h_ |
| #include <dom/html/html_head_element.h> |
| #include "html/html_element.h" |
| struct dom_html_head_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| }; |
| /* Create a dom_html_head_element object */ |
| dom_exception _dom_html_head_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_head_element **ele); |
| /* Initialise a dom_html_head_element object */ |
| dom_exception _dom_html_head_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_head_element *ele); |
| /* Finalise a dom_html_head_element object */ |
| void _dom_html_head_element_finalise(struct dom_html_head_element *ele); |
| /* Destroy a dom_html_head_element object */ |
| void _dom_html_head_element_destroy(struct dom_html_head_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_head_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_head_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_head_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_HEAD_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_head_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_HEAD_ELEMENT \ |
| _dom_virtual_html_head_element_destroy, \ |
| _dom_html_head_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_heading_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_heading_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_hr_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_hr_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_html_element.c |
|---|
| 0,0 → 1,147 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <stdlib.h> |
| #include "html/html_document.h" |
| #include "html/html_html_element.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_HTML_ELEMENT |
| }, |
| DOM_HTML_HTML_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_html_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_html_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_html_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_html_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_html_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_html_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_html_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_html_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_html_element *ele) |
| { |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_HTML], namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_html_element object |
| * |
| * \param ele The dom_html_html_element object |
| */ |
| void _dom_html_html_element_finalise(struct dom_html_html_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_html_element object |
| * |
| * \param ele The dom_html_html_element object |
| */ |
| void _dom_html_html_element_destroy(struct dom_html_html_element *ele) |
| { |
| _dom_html_html_element_finalise(ele); |
| free(ele); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_html_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_html_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_html_element_destroy((struct dom_html_html_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_html_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* API functions */ |
| dom_exception dom_html_html_element_get_version(dom_html_html_element *element, |
| dom_string **version) |
| { |
| dom_exception ret; |
| dom_string *_memo_version; |
| _memo_version = |
| ((struct dom_html_document *) |
| ((struct dom_node_internal *)element)->owner)->memoised[hds_version]; |
| ret = dom_element_get_attribute(element, _memo_version, version); |
| return ret; |
| } |
| dom_exception dom_html_html_element_set_version(dom_html_html_element *element, |
| dom_string *version) |
| { |
| dom_exception ret; |
| dom_string *_memo_version; |
| _memo_version = |
| ((struct dom_html_document *) |
| ((struct dom_node_internal *)element)->owner)->memoised[hds_version]; |
| ret = dom_element_set_attribute(element, _memo_version, version); |
| return ret; |
| } |
| /contrib/network/netsurf/libdom/src/html/html_html_element.h |
|---|
| 0,0 → 1,52 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_internal_html_html_element_h_ |
| #define dom_internal_html_html_element_h_ |
| #include <dom/html/html_html_element.h> |
| #include "html/html_element.h" |
| struct dom_html_html_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| }; |
| /* Create a dom_html_html_element object */ |
| dom_exception _dom_html_html_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_html_element **ele); |
| /* Initialise a dom_html_html_element object */ |
| dom_exception _dom_html_html_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_html_element *ele); |
| /* Finalise a dom_html_html_element object */ |
| void _dom_html_html_element_finalise(struct dom_html_html_element *ele); |
| /* Destroy a dom_html_html_element object */ |
| void _dom_html_html_element_destroy(struct dom_html_html_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_html_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_html_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_html_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_HTML_ELEMENT_PROTECT_VTABLE \ |
| _dom_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_HTML_ELEMENT \ |
| _dom_virtual_html_html_element_destroy, \ |
| _dom_html_html_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_iframe_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_iframe_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_image_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_image_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_input_element.c |
|---|
| 0,0 → 1,485 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/html/html_input_element.h> |
| #include "html/html_document.h" |
| #include "html/html_input_element.h" |
| #include "core/node.h" |
| #include "core/attr.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_INPUT_ELEMENT |
| }, |
| DOM_HTML_INPUT_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_input_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_input_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_input_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_input_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_input_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_input_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_input_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_input_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_input_element *ele) |
| { |
| ele->form = NULL; |
| ele->default_checked = false; |
| ele->default_checked_set = false; |
| ele->default_value = NULL; |
| ele->default_value_set = false; |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_INPUT], |
| namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_input_element object |
| * |
| * \param ele The dom_html_input_element object |
| */ |
| void _dom_html_input_element_finalise(struct dom_html_input_element *ele) |
| { |
| if (ele->default_value != NULL) { |
| dom_string_unref(ele->default_value); |
| ele->default_value = NULL; |
| } |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_input_element object |
| * |
| * \param ele The dom_html_input_element object |
| */ |
| void _dom_html_input_element_destroy(struct dom_html_input_element *ele) |
| { |
| _dom_html_input_element_finalise(ele); |
| free(ele); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| /** |
| * Get the disabled property |
| * |
| * \param ele The dom_html_input_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_get_disabled(dom_html_input_element *ele, |
| bool *disabled) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /** |
| * Set the disabled property |
| * |
| * \param ele The dom_html_input_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_set_disabled(dom_html_input_element *ele, |
| bool disabled) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /** |
| * Get the readOnly property |
| * |
| * \param ele The dom_html_input_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_get_read_only(dom_html_input_element *ele, |
| bool *read_only) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "readonly", |
| SLEN("readonly"), read_only); |
| } |
| /** |
| * Set the readOnly property |
| * |
| * \param ele The dom_html_input_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_set_read_only(dom_html_input_element *ele, |
| bool read_only) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "readonly", |
| SLEN("readonly"), read_only); |
| } |
| /** |
| * Get the checked property |
| * |
| * \param ele The dom_html_input_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_get_checked(dom_html_input_element *ele, |
| bool *checked) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "checked", |
| SLEN("checked"), checked); |
| } |
| /** |
| * Set the checked property |
| * |
| * \param ele The dom_html_input_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_set_checked(dom_html_input_element *ele, |
| bool checked) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "checked", |
| SLEN("checked"), checked); |
| } |
| /** |
| * Get the defaultValue property |
| * |
| * \param ele The dom_html_input_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_get_default_value( |
| dom_html_input_element *ele, dom_string **default_value) |
| { |
| *default_value = ele->default_value; |
| if (*default_value != NULL) |
| dom_string_ref(*default_value); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the defaultValue property |
| * |
| * \param ele The dom_html_input_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_set_default_value( |
| dom_html_input_element *ele, dom_string *default_value) |
| { |
| if (ele->default_value != NULL) |
| dom_string_unref(ele->default_value); |
| ele->default_value = default_value; |
| ele->default_value_set = true; |
| if (ele->default_value != NULL) |
| dom_string_ref(ele->default_value); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the defaultChecked property |
| * |
| * \param ele The dom_html_input_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_get_default_checked( |
| dom_html_input_element *ele, bool *default_checked) |
| { |
| *default_checked = ele->default_checked; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the defaultChecked property |
| * |
| * \param ele The dom_html_input_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_set_default_checked( |
| dom_html_input_element *ele, bool default_checked) |
| { |
| ele->default_checked = default_checked; |
| ele->default_checked_set = true; |
| return DOM_NO_ERR; |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_input_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| dom_html_input_element *input = (dom_html_input_element *)ele; |
| dom_html_document *html = (dom_html_document *)(ele->base.owner); |
| /** \todo Find some way to do the equiv for default_checked to be |
| * false instead of true. Some end-tag hook in the binding perhaps? |
| */ |
| if (dom_string_caseless_isequal(name, html->memoised[hds_checked])) { |
| if (input->default_checked_set == false) { |
| input->default_checked = true; |
| input->default_checked_set = true; |
| } |
| } |
| if (dom_string_caseless_isequal(name, html->memoised[hds_value])) { |
| if (input->default_value_set == false) { |
| input->default_value = value; |
| dom_string_ref(value); |
| input->default_value_set = true; |
| } |
| } |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_input_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_input_element_destroy((struct dom_html_input_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_input_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* API functions */ |
| #define SIMPLE_GET(attr) \ |
| dom_exception dom_html_input_element_get_##attr( \ |
| dom_html_input_element *element, \ |
| dom_string **attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_get_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| #define SIMPLE_SET(attr) \ |
| dom_exception dom_html_input_element_set_##attr( \ |
| dom_html_input_element *element, \ |
| dom_string *attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_set_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| #define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) |
| SIMPLE_GET_SET(accept); |
| SIMPLE_GET_SET(access_key); |
| SIMPLE_GET_SET(align); |
| SIMPLE_GET_SET(alt); |
| SIMPLE_GET_SET(name); |
| SIMPLE_GET_SET(size); |
| SIMPLE_GET_SET(src); |
| SIMPLE_GET(type); |
| SIMPLE_GET_SET(use_map); |
| SIMPLE_GET_SET(value); |
| dom_exception dom_html_input_element_get_tab_index( |
| dom_html_input_element *input, int32_t *tab_index) |
| { |
| return dom_html_element_get_int32_t_property(&input->base, "tabindex", |
| SLEN("tabindex"), tab_index); |
| } |
| dom_exception dom_html_input_element_set_tab_index( |
| dom_html_input_element *input, uint32_t tab_index) |
| { |
| return dom_html_element_set_int32_t_property(&input->base, "tabindex", |
| SLEN("tabindex"), tab_index); |
| } |
| dom_exception dom_html_input_element_get_max_length( |
| dom_html_input_element *input, int32_t *max_length) |
| { |
| return dom_html_element_get_int32_t_property(&input->base, "maxlength", |
| SLEN("maxlength"), max_length); |
| } |
| dom_exception dom_html_input_element_set_max_length( |
| dom_html_input_element *input, uint32_t max_length) |
| { |
| return dom_html_element_set_int32_t_property(&input->base, "maxlength", |
| SLEN("maxlength"), max_length); |
| } |
| dom_exception dom_html_input_element_get_form( |
| dom_html_input_element *input, dom_html_form_element **form) |
| { |
| *form = input->form; |
| if (*form != NULL) |
| dom_node_ref(*form); |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_html_input_element_set_form( |
| dom_html_input_element *input, dom_html_form_element *form) |
| { |
| input->form = form; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Blur this control |
| * |
| * \param ele The form object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_blur(dom_html_input_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ |
| return _dom_dispatch_generic_event((dom_document *) doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_blur], true, |
| true, &success); |
| } |
| /** |
| * Focus this control |
| * |
| * \param ele The form object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_focus(dom_html_input_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ |
| return _dom_dispatch_generic_event((dom_document *)doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_focus], true, |
| true, &success); |
| } |
| /** |
| * Select this control |
| * |
| * \param ele The form object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_select(dom_html_input_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ |
| return _dom_dispatch_generic_event((dom_document *)doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_select], true, |
| true, &success); |
| } |
| /** |
| * Click this control |
| * |
| * \param ele The form object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_input_element_click(dom_html_input_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /** \todo Is this is meant to check/uncheck boxes, radios etc */ |
| /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ |
| return _dom_dispatch_generic_event((dom_document *)doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_click], true, |
| true, &success); |
| } |
| /contrib/network/netsurf/libdom/src/html/html_input_element.h |
|---|
| 0,0 → 1,63 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_html_input_element_h_ |
| #define dom_internal_html_input_element_h_ |
| #include <dom/html/html_input_element.h> |
| #include "html/html_element.h" |
| struct dom_html_input_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| struct dom_html_form_element *form; |
| /**< The form associated with the input */ |
| bool default_checked; /**< Initial checked value */ |
| bool default_checked_set; /**< Whether default_checked has been set */ |
| dom_string *default_value; /**< Initial value */ |
| bool default_value_set; /**< Whether default_value has been set */ |
| }; |
| /* Create a dom_html_input_element object */ |
| dom_exception _dom_html_input_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_input_element **ele); |
| /* Initialise a dom_html_input_element object */ |
| dom_exception _dom_html_input_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_input_element *ele); |
| /* Finalise a dom_html_input_element object */ |
| void _dom_html_input_element_finalise(struct dom_html_input_element *ele); |
| /* Destroy a dom_html_input_element object */ |
| void _dom_html_input_element_destroy(struct dom_html_input_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_input_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_input_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_input_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_INPUT_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_input_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_INPUT_ELEMENT \ |
| _dom_virtual_html_input_element_destroy, \ |
| _dom_html_input_element_copy |
| /* Internal function for bindings */ |
| dom_exception _dom_html_input_element_set_form( |
| dom_html_input_element *input, dom_html_form_element *form); |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_isindex_element.c |
|---|
| 0,0 → 1,146 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <stdlib.h> |
| #include "html/html_isindex_element.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_ISINDEX_ELEMENT |
| }, |
| DOM_HTML_ISINDEX_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_isindex_element object |
| * |
| * \param doc The document object |
| * \param form The form element which contains this element |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_isindex_element_create(struct dom_html_document *doc, |
| struct dom_html_form_element *form, |
| struct dom_html_isindex_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_isindex_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_isindex_element_initialise(doc, form, *ele); |
| } |
| /** |
| * Initialise a dom_html_isindex_element object |
| * |
| * \param doc The document object |
| * \param form The form element which contains this element |
| * \param ele The dom_html_isindex_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_isindex_element_initialise(struct dom_html_document *doc, |
| struct dom_html_form_element *form, |
| struct dom_html_isindex_element *ele) |
| { |
| dom_string *name = NULL; |
| dom_exception err; |
| UNUSED(form); |
| err = dom_string_create((const uint8_t *) "ISINDEX", SLEN("ISINDEX"), |
| &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_html_element_initialise(doc, &ele->base, name, NULL, NULL); |
| dom_string_unref(name); |
| return err; |
| } |
| /** |
| * Finalise a dom_html_isindex_element object |
| * |
| * \param ele The dom_html_isindex_element object |
| */ |
| void _dom_html_isindex_element_finalise(struct dom_html_isindex_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_isindex_element object |
| * |
| * \param ele The dom_html_isindex_element object |
| */ |
| void _dom_html_isindex_element_destroy(struct dom_html_isindex_element *ele) |
| { |
| _dom_html_isindex_element_finalise(ele); |
| free(ele); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_isindex_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_isindex_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_isindex_element_destroy((struct dom_html_isindex_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_isindex_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| /** |
| * Get the form element which contains this element |
| * |
| * \param ele The dom_html_isindex_element |
| * \param form The form element |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_isindex_element_get_form(dom_html_isindex_element *ele, |
| struct dom_html_form_element **form) |
| { |
| UNUSED(ele); |
| UNUSED(form); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/html/html_isindex_element.h |
|---|
| 0,0 → 1,52 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_internal_html_isindex_element_h_ |
| #define dom_internal_html_isindex_element_h_ |
| #include <dom/html/html_isindex_element.h> |
| #include "html/html_element.h" |
| struct dom_html_isindex_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| }; |
| /* Create a dom_html_isindex_element object */ |
| dom_exception _dom_html_isindex_element_create(struct dom_html_document *doc, |
| struct dom_html_form_element *form, |
| struct dom_html_isindex_element **ele); |
| /* Initialise a dom_html_isindex_element object */ |
| dom_exception _dom_html_isindex_element_initialise(struct dom_html_document *doc, |
| struct dom_html_form_element *form, |
| struct dom_html_isindex_element *ele); |
| /* Finalise a dom_html_isindex_element object */ |
| void _dom_html_isindex_element_finalise(struct dom_html_isindex_element *ele); |
| /* Destroy a dom_html_isindex_element object */ |
| void _dom_html_isindex_element_destroy(struct dom_html_isindex_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_isindex_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_isindex_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_isindex_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_ISINDEX_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_isindex_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_ISINDEX_ELEMENT \ |
| _dom_virtual_html_isindex_element_destroy, \ |
| _dom_html_isindex_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_label_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_label_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_legend_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_legend_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_li_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_li_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_link_element.c |
|---|
| 0,0 → 1,194 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include "html/html_document.h" |
| #include "html/html_link_element.h" |
| #include "core/node.h" |
| #include "core/attr.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_LINK_ELEMENT |
| }, |
| DOM_HTML_LINK_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_link_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_link_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_link_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_link_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_link_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_link_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_link_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_link_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_link_element *ele) |
| { |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_LINK], |
| namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_link_element object |
| * |
| * \param ele The dom_html_link_element object |
| */ |
| void _dom_html_link_element_finalise(struct dom_html_link_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_link_element object |
| * |
| * \param ele The dom_html_link_element object |
| */ |
| void _dom_html_link_element_destroy(struct dom_html_link_element *ele) |
| { |
| _dom_html_link_element_finalise(ele); |
| free(ele); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| /** |
| * Get the disabled property |
| * |
| * \param ele The dom_html_link_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_link_element_get_disabled(dom_html_link_element *ele, |
| bool *disabled) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /** |
| * Set the disabled property |
| * |
| * \param ele The dom_html_link_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_link_element_set_disabled(dom_html_link_element *ele, |
| bool disabled) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_link_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_link_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_link_element_destroy((struct dom_html_link_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_link_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* API functions */ |
| #define SIMPLE_GET_SET(attr) \ |
| dom_exception dom_html_link_element_get_##attr( \ |
| dom_html_link_element *element, \ |
| dom_string **attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_get_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } \ |
| \ |
| dom_exception dom_html_link_element_set_##attr( \ |
| dom_html_link_element *element, \ |
| dom_string *attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_set_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| SIMPLE_GET_SET(charset) |
| SIMPLE_GET_SET(href) |
| SIMPLE_GET_SET(hreflang) |
| SIMPLE_GET_SET(media) |
| SIMPLE_GET_SET(rel) |
| SIMPLE_GET_SET(rev) |
| SIMPLE_GET_SET(target) |
| SIMPLE_GET_SET(type) |
| /contrib/network/netsurf/libdom/src/html/html_link_element.h |
|---|
| 0,0 → 1,52 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_internal_html_link_element_h_ |
| #define dom_internal_html_link_element_h_ |
| #include <dom/html/html_link_element.h> |
| #include "html/html_element.h" |
| struct dom_html_link_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| }; |
| /* Create a dom_html_link_element object */ |
| dom_exception _dom_html_link_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_link_element **ele); |
| /* Initialise a dom_html_link_element object */ |
| dom_exception _dom_html_link_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_link_element *ele); |
| /* Finalise a dom_html_link_element object */ |
| void _dom_html_link_element_finalise(struct dom_html_link_element *ele); |
| /* Destroy a dom_html_link_element object */ |
| void _dom_html_link_element_destroy(struct dom_html_link_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_link_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_link_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_link_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_LINK_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_link_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_LINK_ELEMENT \ |
| _dom_virtual_html_link_element_destroy, \ |
| _dom_html_link_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_map_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_map_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_menu_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_menu_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_meta_element.c |
|---|
| 0,0 → 1,157 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <stdlib.h> |
| #include "html/html_document.h" |
| #include "html/html_meta_element.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_META_ELEMENT |
| }, |
| DOM_HTML_META_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_meta_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_meta_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_meta_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_meta_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_meta_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_meta_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_meta_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_meta_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_meta_element *ele) |
| { |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_META], |
| namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_meta_element object |
| * |
| * \param ele The dom_html_meta_element object |
| */ |
| void _dom_html_meta_element_finalise(struct dom_html_meta_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_meta_element object |
| * |
| * \param ele The dom_html_meta_element object |
| */ |
| void _dom_html_meta_element_destroy(struct dom_html_meta_element *ele) |
| { |
| _dom_html_meta_element_finalise(ele); |
| free(ele); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_meta_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_meta_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_meta_element_destroy((struct dom_html_meta_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_meta_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* API functions */ |
| #define SIMPLE_GET_SET(attr) \ |
| dom_exception dom_html_meta_element_get_##attr( \ |
| dom_html_meta_element *element, \ |
| dom_string **attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_get_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } \ |
| \ |
| dom_exception dom_html_meta_element_set_##attr( \ |
| dom_html_meta_element *element, \ |
| dom_string *attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_set_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| SIMPLE_GET_SET(content) |
| SIMPLE_GET_SET(http_equiv) |
| SIMPLE_GET_SET(name) |
| SIMPLE_GET_SET(scheme) |
| /contrib/network/netsurf/libdom/src/html/html_meta_element.h |
|---|
| 0,0 → 1,52 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_internal_html_meta_element_h_ |
| #define dom_internal_html_meta_element_h_ |
| #include <dom/html/html_meta_element.h> |
| #include "html/html_element.h" |
| struct dom_html_meta_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| }; |
| /* Create a dom_html_meta_element object */ |
| dom_exception _dom_html_meta_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_meta_element **ele); |
| /* Initialise a dom_html_meta_element object */ |
| dom_exception _dom_html_meta_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_meta_element *ele); |
| /* Finalise a dom_html_meta_element object */ |
| void _dom_html_meta_element_finalise(struct dom_html_meta_element *ele); |
| /* Destroy a dom_html_meta_element object */ |
| void _dom_html_meta_element_destroy(struct dom_html_meta_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_meta_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_meta_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_meta_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_META_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_meta_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_META_ELEMENT \ |
| _dom_virtual_html_meta_element_destroy, \ |
| _dom_html_meta_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_mod_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_mod_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_object_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_object_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_olist_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_olist_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_opt_group_element.c |
|---|
| 0,0 → 1,191 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/html/html_opt_group_element.h> |
| #include "html/html_document.h" |
| #include "html/html_opt_group_element.h" |
| #include "core/node.h" |
| #include "core/attr.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_OPT_GROUP_ELEMENT |
| }, |
| DOM_HTML_OPT_GROUP_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_opt_group_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_opt_group_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_opt_group_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_opt_group_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_opt_group_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_opt_group_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_opt_group_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_opt_group_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_opt_group_element *ele) |
| { |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_OPTGROUP], |
| namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_opt_group_element object |
| * |
| * \param ele The dom_html_opt_group_element object |
| */ |
| void _dom_html_opt_group_element_finalise(struct dom_html_opt_group_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_opt_group_element object |
| * |
| * \param ele The dom_html_opt_group_element object |
| */ |
| void _dom_html_opt_group_element_destroy(struct dom_html_opt_group_element *ele) |
| { |
| _dom_html_opt_group_element_finalise(ele); |
| free(ele); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| /** |
| * Get the disabled property |
| * |
| * \param ele The dom_html_opt_group_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_opt_group_element_get_disabled(dom_html_opt_group_element *ele, |
| bool *disabled) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /** |
| * Set the disabled property |
| * |
| * \param ele The dom_html_opt_group_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_opt_group_element_set_disabled(dom_html_opt_group_element *ele, |
| bool disabled) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_opt_group_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_opt_group_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_opt_group_element_destroy((struct dom_html_opt_group_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_opt_group_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* API functions */ |
| #define SIMPLE_GET(attr) \ |
| dom_exception dom_html_opt_group_element_get_##attr( \ |
| dom_html_opt_group_element *element, \ |
| dom_string **attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_get_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| #define SIMPLE_SET(attr) \ |
| dom_exception dom_html_opt_group_element_set_##attr( \ |
| dom_html_opt_group_element *element, \ |
| dom_string *attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_set_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| #define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) |
| SIMPLE_GET_SET(label); |
| /contrib/network/netsurf/libdom/src/html/html_opt_group_element.h |
|---|
| 0,0 → 1,51 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_html_opt_group_element_h_ |
| #define dom_internal_html_opt_group_element_h_ |
| #include <dom/html/html_opt_group_element.h> |
| #include "html/html_element.h" |
| struct dom_html_opt_group_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| }; |
| /* Create a dom_html_opt_group_element object */ |
| dom_exception _dom_html_opt_group_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_opt_group_element **ele); |
| /* Initialise a dom_html_opt_group_element object */ |
| dom_exception _dom_html_opt_group_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_opt_group_element *ele); |
| /* Finalise a dom_html_opt_group_element object */ |
| void _dom_html_opt_group_element_finalise(struct dom_html_opt_group_element *ele); |
| /* Destroy a dom_html_opt_group_element object */ |
| void _dom_html_opt_group_element_destroy(struct dom_html_opt_group_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_opt_group_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_opt_group_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_opt_group_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_OPT_GROUP_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_opt_group_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_OPT_GROUP_ELEMENT \ |
| _dom_virtual_html_opt_group_element_destroy, \ |
| _dom_html_opt_group_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_option_element.c |
|---|
| 0,0 → 1,364 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/html/html_option_element.h> |
| #include <dom/html/html_select_element.h> |
| #include "html/html_document.h" |
| #include "html/html_option_element.h" |
| #include "core/node.h" |
| #include "core/attr.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_OPTION_ELEMENT |
| }, |
| DOM_HTML_OPTION_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_option_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_option_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_option_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_option_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_option_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_option_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_option_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_option_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_option_element *ele) |
| { |
| ele->default_selected = false; |
| ele->default_selected_set = false; |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_OPTION], |
| namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_option_element object |
| * |
| * \param ele The dom_html_option_element object |
| */ |
| void _dom_html_option_element_finalise(struct dom_html_option_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_option_element object |
| * |
| * \param ele The dom_html_option_element object |
| */ |
| void _dom_html_option_element_destroy(struct dom_html_option_element *ele) |
| { |
| _dom_html_option_element_finalise(ele); |
| free(ele); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| dom_exception dom_html_option_element_get_form( |
| dom_html_option_element *option, dom_html_form_element **form) |
| { |
| dom_html_document *doc; |
| dom_node_internal *select = ((dom_node_internal *) option)->parent; |
| doc = (dom_html_document *) ((dom_node_internal *) option)->owner; |
| /* Search ancestor chain for SELECT element */ |
| while (select != NULL) { |
| if (select->type == DOM_ELEMENT_NODE && |
| dom_string_caseless_isequal(select->name, |
| doc->memoised[hds_SELECT])) |
| break; |
| select = select->parent; |
| } |
| if (select != NULL) { |
| return dom_html_select_element_get_form((dom_html_select_element *) select, |
| form); |
| } |
| *form = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the defaultSelected property |
| * |
| * \param option The dom_html_option_element object |
| * \param default_selected Pointer to location to receive value |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_option_element_get_default_selected( |
| dom_html_option_element *option, bool *default_selected) |
| { |
| *default_selected = option->default_selected; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the defaultSelected property |
| * |
| * \param option The dom_html_option_element object |
| * \param default_selected New value for property |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_option_element_set_default_selected( |
| dom_html_option_element *option, bool default_selected) |
| { |
| option->default_selected = default_selected; |
| option->default_selected_set = true; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the text contained in the option |
| * |
| * \param option The dom_html_option_element object |
| * \param text Pointer to location to receive text |
| * \return DOM_NO_ERR on success, appropriate error otherwise |
| */ |
| dom_exception dom_html_option_element_get_text( |
| dom_html_option_element *option, dom_string **text) |
| { |
| return dom_node_get_text_content(option, text); |
| } |
| /** |
| * Obtain the index of this option in its parent |
| * |
| * \param option The dom_html_option_element object |
| * \param index Pointer to receive zero-based index |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_option_element_get_index( |
| dom_html_option_element *option, unsigned long *index) |
| { |
| UNUSED(option); |
| UNUSED(index); |
| /** \todo Implement */ |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Get the disabled property |
| * |
| * \param ele The dom_html_option_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_option_element_get_disabled(dom_html_option_element *ele, |
| bool *disabled) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /** |
| * Set the disabled property |
| * |
| * \param ele The dom_html_option_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_option_element_set_disabled(dom_html_option_element *ele, |
| bool disabled) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /** |
| * Get the label property |
| * |
| * \param option The dom_html_option_element object |
| * \param label Pointer to location to receive label |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_option_element_get_label( |
| dom_html_option_element *option, dom_string **label) |
| { |
| dom_html_document *doc; |
| doc = (dom_html_document *) ((dom_node_internal *) option)->owner; |
| return dom_element_get_attribute(option, |
| doc->memoised[hds_label], label); |
| } |
| /** |
| * Set the label property |
| * |
| * \param option The dom_html_option_element object |
| * \param label Label value |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_option_element_set_label( |
| dom_html_option_element *option, dom_string *label) |
| { |
| dom_html_document *doc; |
| doc = (dom_html_document *) ((dom_node_internal *) option)->owner; |
| return dom_element_set_attribute(option, |
| doc->memoised[hds_label], label); |
| } |
| /** |
| * Get the selected property |
| * |
| * \param ele The dom_html_option_element object |
| * \param selected The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_option_element_get_selected(dom_html_option_element *ele, |
| bool *selected) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "selected", |
| SLEN("selected"), selected); |
| } |
| /** |
| * Set the selected property |
| * |
| * \param ele The dom_html_option_element object |
| * \param selected The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_option_element_set_selected(dom_html_option_element *ele, |
| bool selected) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "selected", |
| SLEN("selected"), selected); |
| } |
| /** |
| * Get the value property |
| * |
| * \param option The dom_html_option_element object |
| * \param value Pointer to location to receive property value |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_option_element_get_value( |
| dom_html_option_element *option, dom_string **value) |
| { |
| dom_html_document *doc; |
| bool has_value = false; |
| dom_exception err; |
| doc = (dom_html_document *) ((dom_node_internal *) option)->owner; |
| err = dom_element_has_attribute(option, |
| doc->memoised[hds_value], &has_value); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (has_value) { |
| return dom_element_get_attribute(option, |
| doc->memoised[hds_value], value); |
| } |
| return dom_html_option_element_get_text(option, value); |
| } |
| /** |
| * Set the value property |
| * |
| * \param option The dom_html_option_element object |
| * \param value Property value |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_option_element_set_value( |
| dom_html_option_element *option, dom_string *value) |
| { |
| dom_html_document *doc; |
| doc = (dom_html_document *) ((dom_node_internal *) option)->owner; |
| return dom_element_set_attribute(option, |
| doc->memoised[hds_value], value); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_option_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| dom_html_option_element *option = (dom_html_option_element *)ele; |
| dom_html_document *html = (dom_html_document *)(ele->base.owner); |
| /** \todo Find some way to do the equiv for default_selected to be |
| * false instead of true. Some end-tag hook in the binding perhaps? |
| */ |
| if (dom_string_caseless_isequal(name, html->memoised[hds_selected])) { |
| if (option->default_selected_set == false) { |
| option->default_selected = true; |
| option->default_selected_set = true; |
| } |
| } |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_option_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_option_element_destroy((struct dom_html_option_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_option_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /contrib/network/netsurf/libdom/src/html/html_option_element.h |
|---|
| 0,0 → 1,54 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_html_option_element_h_ |
| #define dom_internal_html_option_element_h_ |
| #include <dom/html/html_option_element.h> |
| #include "html/html_element.h" |
| struct dom_html_option_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| bool default_selected; /**< Initial selected value */ |
| bool default_selected_set; /**< Whether default_selected has been set */ |
| }; |
| /* Create a dom_html_option_element object */ |
| dom_exception _dom_html_option_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_option_element **ele); |
| /* Initialise a dom_html_option_element object */ |
| dom_exception _dom_html_option_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_option_element *ele); |
| /* Finalise a dom_html_option_element object */ |
| void _dom_html_option_element_finalise(struct dom_html_option_element *ele); |
| /* Destroy a dom_html_option_element object */ |
| void _dom_html_option_element_destroy(struct dom_html_option_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_option_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_option_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_option_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_OPTION_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_option_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_OPTION_ELEMENT \ |
| _dom_virtual_html_option_element_destroy, \ |
| _dom_html_option_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_options_collection.c |
|---|
| 0,0 → 1,243 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <libwapcaplet/libwapcaplet.h> |
| #include "html/html_options_collection.h" |
| #include "core/node.h" |
| #include "core/element.h" |
| #include "core/string.h" |
| #include "utils/utils.h" |
| /*-----------------------------------------------------------------------*/ |
| /* Constructor and destructor */ |
| /** |
| * Create a dom_html_options_collection |
| * |
| * \param doc The document |
| * \param root The root element of the collection |
| * \param ic The callback function used to determin whether certain node |
| * beint32_ts to the collection |
| * \param col The result collection object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_options_collection_create(struct dom_html_document *doc, |
| struct dom_node_internal *root, |
| dom_callback_is_in_collection ic, |
| void *ctx, |
| struct dom_html_options_collection **col) |
| { |
| *col = malloc(sizeof(dom_html_options_collection)); |
| if (*col == NULL) |
| return DOM_NO_MEM_ERR; |
| return _dom_html_options_collection_initialise(doc, *col, root, |
| ic, ctx); |
| } |
| /** |
| * Intialiase a dom_html_options_collection |
| * |
| * \param doc The document |
| * \param col The collection object to be initialised |
| * \param root The root element of the collection |
| * \param ic The callback function used to determin whether certain node |
| * beint32_ts to the collection |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception _dom_html_options_collection_initialise(struct dom_html_document *doc, |
| struct dom_html_options_collection *col, |
| struct dom_node_internal *root, |
| dom_callback_is_in_collection ic, void *ctx) |
| { |
| return _dom_html_collection_initialise(doc, &col->base, root, ic, ctx); |
| } |
| /** |
| * Finalise a dom_html_options_collection object |
| * |
| * \param col The dom_html_options_collection object |
| */ |
| void _dom_html_options_collection_finalise(struct dom_html_options_collection *col) |
| { |
| _dom_html_collection_finalise(&col->base); |
| } |
| /** |
| * Destroy a dom_html_options_collection object |
| * \param col The dom_html_options_collection object |
| */ |
| void _dom_html_options_collection_destroy(struct dom_html_options_collection *col) |
| { |
| _dom_html_options_collection_finalise(col); |
| free(col); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public API */ |
| /** |
| * Get the length of this dom_html_options_collection |
| * |
| * \param col The dom_html_options_collection object |
| * \param len The returned length of this collection |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_options_collection_get_length(dom_html_options_collection *col, |
| uint32_t *len) |
| { |
| return dom_html_collection_get_length(&col->base, len); |
| } |
| /** |
| * Set the length of this dom_html_options_collection |
| * |
| * \param col The dom_html_options_collection object |
| * \param len The length of this collection to be set |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_options_collection_set_length( |
| dom_html_options_collection *col, uint32_t len) |
| { |
| UNUSED(col); |
| UNUSED(len); |
| /* TODO: how to deal with this */ |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Get the node with certain index |
| * |
| * \param col The dom_html_options_collection object |
| * \param index The index number based on zero |
| * \param node The returned node object |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_options_collection_item(dom_html_options_collection *col, |
| uint32_t index, struct dom_node **node) |
| { |
| return dom_html_collection_item(&col->base, index, node); |
| } |
| /** |
| * Get the node in the collection according name |
| * |
| * \param col The collection |
| * \param name The name of target node |
| * \param node The returned node object |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_options_collection_named_item(dom_html_options_collection *col, |
| dom_string *name, struct dom_node **node) |
| { |
| struct dom_node_internal *n = col->base.root; |
| dom_string *kname; |
| dom_exception err; |
| /* Search for an element with an appropriate ID */ |
| err = dom_html_collection_named_item(&col->base, name, node); |
| if (err == DOM_NO_ERR && *node != NULL) |
| return err; |
| /* Didn't find one, so consider name attribute */ |
| err = dom_string_create_interned((const uint8_t *) "name", SLEN("name"), |
| &kname); |
| if (err != DOM_NO_ERR) |
| return err; |
| while (n != NULL) { |
| if (n->type == DOM_ELEMENT_NODE && |
| col->base.ic(n, col->base.ctx) == true) { |
| dom_string *nval = NULL; |
| err = dom_element_get_attribute(n, kname, &nval); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(kname); |
| return err; |
| } |
| if (nval != NULL && dom_string_isequal(name, nval)) { |
| *node = (struct dom_node *) n; |
| dom_node_ref(n); |
| dom_string_unref(nval); |
| dom_string_unref(kname); |
| return DOM_NO_ERR; |
| } |
| if (nval != NULL) |
| dom_string_unref(nval); |
| } |
| /* Depth first iterating */ |
| if (n->first_child != NULL) { |
| n = n->first_child; |
| } else if (n->next != NULL) { |
| n = n->next; |
| } else { |
| /* No children and siblings */ |
| struct dom_node_internal *parent = n->parent; |
| while (parent != col->base.root && |
| n == parent->last_child) { |
| n = parent; |
| parent = parent->parent; |
| } |
| if (parent == col->base.root) |
| n = NULL; |
| else |
| n = n->next; |
| } |
| } |
| dom_string_unref(kname); |
| /* Not found the target node */ |
| *node = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Claim a reference on this collection |
| * |
| * \pram col The collection object |
| */ |
| void dom_html_options_collection_ref(dom_html_options_collection *col) |
| { |
| if (col == NULL) |
| return; |
| col->base.refcnt ++; |
| } |
| /** |
| * Relese a reference on this collection |
| * |
| * \pram col The collection object |
| */ |
| void dom_html_options_collection_unref(dom_html_options_collection *col) |
| { |
| if (col == NULL) |
| return; |
| if (col->base.refcnt > 0) |
| col->base.refcnt --; |
| if (col->base.refcnt == 0) |
| _dom_html_options_collection_destroy(col); |
| } |
| /contrib/network/netsurf/libdom/src/html/html_options_collection.h |
|---|
| 0,0 → 1,43 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_html_options_collection_h_ |
| #define dom_internal_html_options_collection_h_ |
| #include <dom/html/html_options_collection.h> |
| #include "html/html_collection.h" |
| struct dom_node_internal; |
| /** |
| * The html_options_collection structure |
| */ |
| struct dom_html_options_collection { |
| struct dom_html_collection base; |
| /**< The base class */ |
| }; |
| dom_exception _dom_html_options_collection_create(struct dom_html_document *doc, |
| struct dom_node_internal *root, |
| dom_callback_is_in_collection ic, |
| void *ctx, |
| struct dom_html_options_collection **col); |
| dom_exception _dom_html_options_collection_initialise(struct dom_html_document *doc, |
| struct dom_html_options_collection *col, |
| struct dom_node_internal *root, |
| dom_callback_is_in_collection ic, void *ctx); |
| void _dom_html_options_collection_finalise( |
| struct dom_html_options_collection *col); |
| void _dom_html_options_collection_destroy( |
| struct dom_html_options_collection *col); |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_paragraph_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_paragraph_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_param_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_param_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_pre_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_pre_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_quote_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_quote_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_script_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_script_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_select_element.c |
|---|
| 0,0 → 1,624 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/html/html_option_element.h> |
| #include <dom/html/html_options_collection.h> |
| #include "html/html_document.h" |
| #include "html/html_select_element.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_SELECT_ELEMENT |
| }, |
| DOM_HTML_SELECT_ELEMENT_PROTECT_VTABLE |
| }; |
| static bool is_option(struct dom_node_internal *node, void *ctx); |
| /** |
| * Create a dom_html_select_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_select_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_select_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_select_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_select_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_select_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_select_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_select_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_select_element *ele) |
| { |
| ele->form = NULL; |
| ele->options = NULL; |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_SELECT], |
| namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_select_element object |
| * |
| * \param ele The dom_html_select_element object |
| */ |
| void _dom_html_select_element_finalise(struct dom_html_select_element *ele) |
| { |
| if (ele->options != NULL) |
| dom_html_options_collection_unref(ele->options); |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_select_element object |
| * |
| * \param ele The dom_html_select_element object |
| */ |
| void _dom_html_select_element_destroy(struct dom_html_select_element *ele) |
| { |
| _dom_html_select_element_finalise(ele); |
| free(ele); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_select_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_select_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_select_element_destroy((struct dom_html_select_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_select_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| static dom_exception _dom_html_select_element_ensure_collection( |
| dom_html_select_element *ele) |
| { |
| dom_exception err; |
| dom_html_document *doc = (dom_html_document *) dom_node_get_owner(ele); |
| assert(doc != NULL); |
| if (ele->options == NULL) { |
| err = _dom_html_options_collection_create(doc, |
| (dom_node_internal *) ele, |
| is_option, ele, &ele->options); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the type of selection control |
| * |
| * \param ele The Select element |
| * \param type Pointer to location to receive type |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_select_element_get_type( |
| dom_html_select_element *ele, dom_string **type) |
| { |
| dom_html_document *doc = (dom_html_document *) dom_node_get_owner(ele); |
| dom_exception err; |
| bool multiple; |
| err = dom_html_select_element_get_multiple(ele, &multiple); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (multiple) |
| *type = dom_string_ref(doc->memoised[hds_select_multiple]); |
| else |
| *type = dom_string_ref(doc->memoised[hds_select_one]); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the ordinal index of the selected option |
| * |
| * \param ele The element object |
| * \param index The returned index |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_select_element_get_selected_index( |
| dom_html_select_element *ele, int32_t *index) |
| { |
| dom_exception err; |
| uint32_t idx, len; |
| dom_node *option; |
| bool selected; |
| err = dom_html_select_element_get_length(ele, &len); |
| if (err != DOM_NO_ERR) |
| return err; |
| for (idx = 0; idx < len; idx++) { |
| err = dom_html_options_collection_item(ele->options, |
| idx, &option); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_html_option_element_get_selected( |
| (dom_html_option_element *) option, &selected); |
| dom_node_unref(option); |
| if (err != DOM_NO_ERR) |
| return err; |
| if (selected) { |
| *index = idx; |
| return DOM_NO_ERR; |
| } |
| } |
| *index = -1; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the ordinal index of the selected option |
| * |
| * \param ele The element object |
| * \param index The new index |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_select_element_set_selected_index( |
| dom_html_select_element *ele, int32_t index) |
| { |
| UNUSED(ele); |
| UNUSED(index); |
| /** \todo Implement */ |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Get the value of this form control |
| * |
| * \param ele The select element |
| * \param value Pointer to location to receive value |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_select_element_get_value( |
| dom_html_select_element *ele, dom_string **value) |
| { |
| dom_exception err; |
| uint32_t idx, len; |
| dom_node *option; |
| bool selected; |
| err = dom_html_select_element_get_length(ele, &len); |
| if (err != DOM_NO_ERR) |
| return err; |
| for (idx = 0; idx < len; idx++) { |
| err = dom_html_options_collection_item(ele->options, |
| idx, &option); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = dom_html_option_element_get_selected( |
| (dom_html_option_element *) option, &selected); |
| if (err != DOM_NO_ERR) { |
| dom_node_unref(option); |
| return err; |
| } |
| if (selected) { |
| err = dom_html_option_element_get_value( |
| (dom_html_option_element *) option, |
| value); |
| dom_node_unref(option); |
| return err; |
| } |
| } |
| *value = NULL; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the value of this form control |
| * |
| * \param ele The select element |
| * \param value New value |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_select_element_set_value( |
| dom_html_select_element *ele, dom_string *value) |
| { |
| UNUSED(ele); |
| UNUSED(value); |
| /** \todo Implement */ |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Get the number of options in this select element |
| * |
| * \param ele The element object |
| * \param len The returned len |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_select_element_get_length( |
| dom_html_select_element *ele, uint32_t *len) |
| { |
| dom_exception err; |
| err = _dom_html_select_element_ensure_collection(ele); |
| if (err != DOM_NO_ERR) |
| return err; |
| return dom_html_options_collection_get_length(ele->options, len); |
| } |
| /** |
| * Set the number of options in this select element |
| * |
| * \param ele The element object |
| * \param len The new len |
| * \return DOM_NOT_SUPPORTED_ERR. |
| * |
| * todo: how to deal with set the len of the children option objects? |
| */ |
| dom_exception dom_html_select_element_set_length( |
| dom_html_select_element *ele, uint32_t len) |
| { |
| UNUSED(ele); |
| UNUSED(len); |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Get the form associated with a select |
| * |
| * \param select The dom_html_select_element object |
| * \param form Pointer to location to receive form |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_select_element_get_form( |
| dom_html_select_element *select, dom_html_form_element **form) |
| { |
| *form = select->form; |
| if (*form != NULL) |
| dom_node_ref(*form); |
| return DOM_NO_ERR; |
| } |
| /** |
| * The collection of OPTION elements of this element |
| * |
| * \param ele The element object |
| * \param col THe returned collection object |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom__html_select_element_get_options( |
| dom_html_select_element *ele, |
| struct dom_html_options_collection **col) |
| { |
| dom_exception err; |
| err = _dom_html_select_element_ensure_collection(ele); |
| if (err != DOM_NO_ERR) |
| return err; |
| dom_html_options_collection_ref(ele->options); |
| *col = ele->options; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Whether this element is disabled |
| * |
| * \param ele The element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_select_element_get_disabled( |
| dom_html_select_element *ele, bool *disabled) |
| { |
| return dom_html_element_get_bool_property(&ele->base, |
| "disabled", SLEN("disabled"), disabled); |
| } |
| /** |
| * Set the disabled status of this element |
| * |
| * \param ele The element object |
| * \param disabled The disabled status |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_select_element_set_disabled( |
| dom_html_select_element *ele, bool disabled) |
| { |
| return dom_html_element_set_bool_property(&ele->base, |
| "disabled", SLEN("disabled"), disabled); |
| } |
| /** |
| * Whether this element can be multiple selected |
| * |
| * \param ele The element object |
| * \param multiple The returned status |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_select_element_get_multiple( |
| dom_html_select_element *ele, bool *multiple) |
| { |
| return dom_html_element_get_bool_property(&ele->base, |
| "multiple", SLEN("multiple"), multiple); |
| } |
| /** |
| * Set whether this element can be multiple selected |
| * |
| * \param ele The element object |
| * \param multiple The status |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception dom_html_select_element_set_multiple( |
| dom_html_select_element *ele, bool multiple) |
| { |
| return dom_html_element_set_bool_property(&ele->base, |
| "multiple", SLEN("multiple"), multiple); |
| } |
| /** |
| * Get the name property |
| * |
| * \param ele The select element |
| * \param name Pointer to location to receive name |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_select_element_get_name( |
| dom_html_select_element *ele, dom_string **name) |
| { |
| dom_html_document *doc = (dom_html_document *) dom_node_get_owner(ele); |
| return dom_element_get_attribute(ele, |
| doc->memoised[hds_name], name); |
| } |
| /** |
| * Set the name property |
| * |
| * \param ele The select element |
| * \param name New name |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_select_element_set_name( |
| dom_html_select_element *ele, dom_string *name) |
| { |
| dom_html_document *doc = (dom_html_document *) dom_node_get_owner(ele); |
| return dom_element_set_attribute(ele, |
| doc->memoised[hds_name], name); |
| } |
| /** |
| * Get the size property |
| * |
| * \param ele The select element |
| * \param size Pointer to location to receive size |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_select_element_get_size( |
| dom_html_select_element *ele, int32_t *size) |
| { |
| return dom_html_element_get_int32_t_property(&ele->base, "size", |
| SLEN("size"), size); |
| } |
| /** |
| * Set the size property |
| * |
| * \param ele The select element |
| * \param size New size |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_select_element_set_size( |
| dom_html_select_element *ele, int32_t size) |
| { |
| return dom_html_element_set_int32_t_property(&ele->base, "size", |
| SLEN("size"), size); |
| } |
| /** |
| * Get the tabindex property |
| * |
| * \param ele The select element |
| * \param tab_index Pointer to location to receive tab index |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_select_element_get_tab_index( |
| dom_html_select_element *ele, int32_t *tab_index) |
| { |
| return dom_html_element_get_int32_t_property(&ele->base, "tabindex", |
| SLEN("tabindex"), tab_index); |
| } |
| /** |
| * Set the tabindex property |
| * |
| * \param ele The select element |
| * \param tab_index New tab index |
| * \return DOM_NO_ERR on success, appropriate error otherwise. |
| */ |
| dom_exception dom_html_select_element_set_tab_index( |
| dom_html_select_element *ele, int32_t tab_index) |
| { |
| return dom_html_element_set_int32_t_property(&ele->base, "tabindex", |
| SLEN("tabindex"), tab_index); |
| } |
| /* Functions */ |
| dom_exception dom__html_select_element_add(dom_html_select_element *select, |
| struct dom_html_element *ele, struct dom_html_element *before) |
| { |
| UNUSED(select); |
| UNUSED(ele); |
| UNUSED(before); |
| /** \todo Implement */ |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| dom_exception dom_html_select_element_remove(dom_html_select_element *ele, |
| int32_t index) |
| { |
| dom_exception err; |
| uint32_t len; |
| dom_node *option; |
| err = dom_html_select_element_get_length(ele, &len); |
| if (err != DOM_NO_ERR) |
| return err; |
| /* Ensure index is in range */ |
| if (index < 0 || (uint32_t)index >= len) |
| return DOM_NO_ERR; |
| err = dom_html_options_collection_item(ele->options, index, &option); |
| if (err != DOM_NO_ERR) |
| return err; |
| /** \todo What does remove mean? Remove option from tree and destroy it? */ |
| return DOM_NOT_SUPPORTED_ERR; |
| } |
| /** |
| * Blur this control |
| * |
| * \param ele Element to blur |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_select_element_blur(struct dom_html_select_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ |
| return _dom_dispatch_generic_event((dom_document *) doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_blur], true, |
| true, &success); |
| } |
| /** |
| * Focus this control |
| * |
| * \param ele Element to focus |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_select_element_focus(struct dom_html_select_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ |
| return _dom_dispatch_generic_event((dom_document *) doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_focus], true, |
| true, &success); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Helper functions */ |
| /* Test whether certain node is an option node */ |
| bool is_option(struct dom_node_internal *node, void *ctx) |
| { |
| dom_html_select_element *ele = ctx; |
| dom_html_document *doc = (dom_html_document *) dom_node_get_owner(ele); |
| if (dom_string_isequal(node->name, doc->memoised[hds_OPTION])) |
| return true; |
| return false; |
| } |
| dom_exception _dom_html_select_element_set_form( |
| dom_html_select_element *select, dom_html_form_element *form) |
| { |
| select->form = form; |
| return DOM_NO_ERR; |
| } |
| /contrib/network/netsurf/libdom/src/html/html_select_element.h |
|---|
| 0,0 → 1,64 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_internal_html_select_element_h_ |
| #define dom_internal_html_select_element_h_ |
| #include <dom/html/html_select_element.h> |
| #include "html/html_element.h" |
| #include "html/html_options_collection.h" |
| struct dom_html_select_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| int32_t selected; |
| /**< The selected element's index */ |
| dom_html_form_element *form; |
| /**< The form associated with select */ |
| dom_html_options_collection *options; |
| /**< The options objects */ |
| }; |
| /* Create a dom_html_select_element object */ |
| dom_exception _dom_html_select_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_select_element **ele); |
| /* Initialise a dom_html_select_element object */ |
| dom_exception _dom_html_select_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_select_element *ele); |
| /* Finalise a dom_html_select_element object */ |
| void _dom_html_select_element_finalise(struct dom_html_select_element *ele); |
| /* Destroy a dom_html_select_element object */ |
| void _dom_html_select_element_destroy(struct dom_html_select_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_select_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_select_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_select_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_SELECT_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_select_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_SELECT_ELEMENT \ |
| _dom_virtual_html_select_element_destroy, \ |
| _dom_html_select_element_copy |
| /* Internal function for bindings */ |
| dom_exception _dom_html_select_element_set_form( |
| dom_html_select_element *select, dom_html_form_element *form); |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_style_element.c |
|---|
| 0,0 → 1,152 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <stdlib.h> |
| #include "html/html_style_element.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_STYLE_ELEMENT |
| }, |
| DOM_HTML_STYLE_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_style_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_style_element_create(struct dom_html_document *doc, |
| struct dom_html_style_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_style_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_style_element_initialise(doc, *ele); |
| } |
| /** |
| * Initialise a dom_html_style_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_style_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_style_element_initialise(struct dom_html_document *doc, |
| struct dom_html_style_element *ele) |
| { |
| dom_string *name = NULL; |
| dom_exception err; |
| err = dom_string_create((const uint8_t *) "STYLE", SLEN("STYLE"), |
| &name); |
| if (err != DOM_NO_ERR) |
| return err; |
| err = _dom_html_element_initialise(doc, &ele->base, name, NULL, NULL); |
| dom_string_unref(name); |
| return err; |
| } |
| /** |
| * Finalise a dom_html_style_element object |
| * |
| * \param ele The dom_html_style_element object |
| */ |
| void _dom_html_style_element_finalise(struct dom_html_style_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_style_element object |
| * |
| * \param ele The dom_html_style_element object |
| */ |
| void _dom_html_style_element_destroy(struct dom_html_style_element *ele) |
| { |
| _dom_html_style_element_finalise(ele); |
| free(ele); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_style_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_style_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_style_element_destroy((struct dom_html_style_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_style_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| /** |
| * Get the disabled property |
| * |
| * \param ele The dom_html_style_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_style_element_get_disabled(dom_html_style_element *ele, |
| bool *disabled) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /** |
| * Set the disabled property |
| * |
| * \param ele The dom_html_style_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_style_element_set_disabled(dom_html_style_element *ele, |
| bool disabled) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /contrib/network/netsurf/libdom/src/html/html_style_element.h |
|---|
| 0,0 → 1,50 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_internal_html_style_element_h_ |
| #define dom_internal_html_style_element_h_ |
| #include <dom/html/html_style_element.h> |
| #include "html/html_element.h" |
| struct dom_html_style_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| }; |
| /* Create a dom_html_style_element object */ |
| dom_exception _dom_html_style_element_create(struct dom_html_document *doc, |
| struct dom_html_style_element **ele); |
| /* Initialise a dom_html_style_element object */ |
| dom_exception _dom_html_style_element_initialise(struct dom_html_document *doc, |
| struct dom_html_style_element *ele); |
| /* Finalise a dom_html_style_element object */ |
| void _dom_html_style_element_finalise(struct dom_html_style_element *ele); |
| /* Destroy a dom_html_style_element object */ |
| void _dom_html_style_element_destroy(struct dom_html_style_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_style_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_style_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_style_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_STYLE_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_style_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_STYLE_ELEMENT \ |
| _dom_virtual_html_style_element_destroy, \ |
| _dom_html_style_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_table_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_table_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_tablecaption_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_tablecaption_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_tablecell_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_tablecell_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_tablecol_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_tablecol_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_tablerow_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_tablerow_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_tablesection_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_tablesection_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_text_area_element.c |
|---|
| 0,0 → 1,486 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/html/html_text_area_element.h> |
| #include "html/html_document.h" |
| #include "html/html_text_area_element.h" |
| #include "core/node.h" |
| #include "core/attr.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_TEXT_AREA_ELEMENT |
| }, |
| DOM_HTML_TEXT_AREA_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_text_area_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_text_area_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_text_area_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_text_area_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_text_area_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_text_area_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_text_area_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_text_area_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_text_area_element *ele) |
| { |
| ele->form = NULL; |
| ele->default_value = NULL; |
| ele->default_value_set = false; |
| ele->value = NULL; |
| ele->value_set = false; |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_TEXTAREA], |
| namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_text_area_element object |
| * |
| * \param ele The dom_html_text_area_element object |
| */ |
| void _dom_html_text_area_element_finalise(struct dom_html_text_area_element *ele) |
| { |
| if (ele->default_value != NULL) { |
| dom_string_unref(ele->default_value); |
| ele->default_value = NULL; |
| ele->default_value_set = false; |
| } |
| if (ele->value != NULL) { |
| dom_string_unref(ele->value); |
| ele->value = NULL; |
| ele->value_set = false; |
| } |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_text_area_element object |
| * |
| * \param ele The dom_html_text_area_element object |
| */ |
| void _dom_html_text_area_element_destroy(struct dom_html_text_area_element *ele) |
| { |
| _dom_html_text_area_element_finalise(ele); |
| free(ele); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| /** |
| * Get the disabled property |
| * |
| * \param ele The dom_html_text_area_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_get_disabled(dom_html_text_area_element *ele, |
| bool *disabled) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /** |
| * Set the disabled property |
| * |
| * \param ele The dom_html_text_area_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_set_disabled(dom_html_text_area_element *ele, |
| bool disabled) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "disabled", |
| SLEN("disabled"), disabled); |
| } |
| /** |
| * Get the readOnly property |
| * |
| * \param ele The dom_html_text_area_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_get_read_only(dom_html_text_area_element *ele, |
| bool *read_only) |
| { |
| return dom_html_element_get_bool_property(&ele->base, "readonly", |
| SLEN("readonly"), read_only); |
| } |
| /** |
| * Set the readOnly property |
| * |
| * \param ele The dom_html_text_area_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_set_read_only(dom_html_text_area_element *ele, |
| bool read_only) |
| { |
| return dom_html_element_set_bool_property(&ele->base, "readonly", |
| SLEN("readonly"), read_only); |
| } |
| /** |
| * Get the defaultValue property |
| * |
| * \param ele The dom_html_text_area_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_get_default_value( |
| dom_html_text_area_element *ele, dom_string **default_value) |
| { |
| dom_exception err; |
| if (ele->default_value_set == false) { |
| err = dom_node_get_text_content((dom_node *)ele, |
| &ele->default_value); |
| if (err == DOM_NO_ERR) { |
| ele->default_value_set = true; |
| } |
| } |
| *default_value = ele->default_value; |
| if (*default_value != NULL) |
| dom_string_ref(*default_value); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the defaultValue property |
| * |
| * \param ele The dom_html_text_area_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_set_default_value( |
| dom_html_text_area_element *ele, dom_string *default_value) |
| { |
| if (ele->default_value != NULL) |
| dom_string_unref(ele->default_value); |
| ele->default_value = default_value; |
| ele->default_value_set = true; |
| if (ele->default_value != NULL) |
| dom_string_ref(ele->default_value); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the value property |
| * |
| * \param ele The dom_html_text_area_element object |
| * \param disabled The returned status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_get_value( |
| dom_html_text_area_element *ele, dom_string **value) |
| { |
| dom_exception err; |
| if (ele->value_set == false) { |
| err = dom_node_get_text_content((dom_node *)ele, |
| &ele->value); |
| if (err == DOM_NO_ERR) { |
| ele->default_value_set = true; |
| if (ele->default_value_set == false) { |
| ele->default_value_set = true; |
| ele->default_value = ele->value; |
| dom_string_ref(ele->default_value); |
| } |
| } |
| } |
| *value = ele->value; |
| if (*value != NULL) |
| dom_string_ref(*value); |
| return DOM_NO_ERR; |
| } |
| /** |
| * Set the value property |
| * |
| * \param ele The dom_html_text_area_element object |
| * \param disabled The status |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_set_value( |
| dom_html_text_area_element *ele, dom_string *value) |
| { |
| dom_exception err; |
| if (ele->default_value_set == false) { |
| err = dom_node_get_text_content((dom_node *)ele, |
| &ele->default_value); |
| if (err == DOM_NO_ERR) { |
| ele->default_value_set = true; |
| } |
| } |
| if (ele->value != NULL) |
| dom_string_unref(ele->value); |
| ele->value = value; |
| ele->value_set = true; |
| if (ele->value != NULL) |
| dom_string_ref(ele->value); |
| return DOM_NO_ERR; |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_text_area_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_text_area_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_text_area_element_destroy((struct dom_html_text_area_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_text_area_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* API functions */ |
| #define SIMPLE_GET(attr) \ |
| dom_exception dom_html_text_area_element_get_##attr( \ |
| dom_html_text_area_element *element, \ |
| dom_string **attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_get_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| #define SIMPLE_SET(attr) \ |
| dom_exception dom_html_text_area_element_set_##attr( \ |
| dom_html_text_area_element *element, \ |
| dom_string *attr) \ |
| { \ |
| dom_exception ret; \ |
| dom_string *_memo_##attr; \ |
| \ |
| _memo_##attr = \ |
| ((struct dom_html_document *) \ |
| ((struct dom_node_internal *)element)->owner)->\ |
| memoised[hds_##attr]; \ |
| \ |
| ret = dom_element_set_attribute(element, _memo_##attr, attr); \ |
| \ |
| return ret; \ |
| } |
| #define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) |
| SIMPLE_GET_SET(access_key); |
| SIMPLE_GET_SET(name); |
| dom_exception dom_html_text_area_element_get_type( |
| dom_html_text_area_element *text_area, dom_string **type) |
| { |
| dom_html_document *html = (dom_html_document *) |
| ((dom_node_internal *)text_area)->owner; |
| *type = html->memoised[hds_textarea]; |
| dom_string_ref(*type); |
| return DOM_NO_ERR; |
| } |
| dom_exception dom_html_text_area_element_get_tab_index( |
| dom_html_text_area_element *text_area, int32_t *tab_index) |
| { |
| return dom_html_element_get_int32_t_property(&text_area->base, "tabindex", |
| SLEN("tabindex"), tab_index); |
| } |
| dom_exception dom_html_text_area_element_set_tab_index( |
| dom_html_text_area_element *text_area, uint32_t tab_index) |
| { |
| return dom_html_element_set_int32_t_property(&text_area->base, "tabindex", |
| SLEN("tabindex"), tab_index); |
| } |
| dom_exception dom_html_text_area_element_get_cols( |
| dom_html_text_area_element *text_area, int32_t *cols) |
| { |
| return dom_html_element_get_int32_t_property(&text_area->base, "cols", |
| SLEN("cols"), cols); |
| } |
| dom_exception dom_html_text_area_element_set_cols( |
| dom_html_text_area_element *text_area, uint32_t cols) |
| { |
| return dom_html_element_set_int32_t_property(&text_area->base, "cols", |
| SLEN("cols"), cols); |
| } |
| dom_exception dom_html_text_area_element_get_rows( |
| dom_html_text_area_element *text_area, int32_t *rows) |
| { |
| return dom_html_element_get_int32_t_property(&text_area->base, "rows", |
| SLEN("rows"), rows); |
| } |
| dom_exception dom_html_text_area_element_set_rows( |
| dom_html_text_area_element *text_area, uint32_t rows) |
| { |
| return dom_html_element_set_int32_t_property(&text_area->base, "rows", |
| SLEN("rows"), rows); |
| } |
| dom_exception dom_html_text_area_element_get_form( |
| dom_html_text_area_element *text_area, dom_html_form_element **form) |
| { |
| *form = text_area->form; |
| if (*form != NULL) |
| dom_node_ref(*form); |
| return DOM_NO_ERR; |
| } |
| dom_exception _dom_html_text_area_element_set_form( |
| dom_html_text_area_element *text_area, dom_html_form_element *form) |
| { |
| text_area->form = form; |
| return DOM_NO_ERR; |
| } |
| /** |
| * Blur this control |
| * |
| * \param ele The form object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_blur(dom_html_text_area_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ |
| return _dom_dispatch_generic_event((dom_document *) doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_blur], true, |
| true, &success); |
| } |
| /** |
| * Focus this control |
| * |
| * \param ele The form object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_focus(dom_html_text_area_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ |
| return _dom_dispatch_generic_event((dom_document *)doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_focus], true, |
| true, &success); |
| } |
| /** |
| * Select this control |
| * |
| * \param ele The form object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception dom_html_text_area_element_select(dom_html_text_area_element *ele) |
| { |
| struct dom_html_document *doc = |
| (dom_html_document *) dom_node_get_owner(ele); |
| bool success = false; |
| assert(doc != NULL); |
| /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ |
| return _dom_dispatch_generic_event((dom_document *)doc, |
| (dom_event_target *) ele, |
| doc->memoised[hds_select], true, |
| true, &success); |
| } |
| /contrib/network/netsurf/libdom/src/html/html_text_area_element.h |
|---|
| 0,0 → 1,62 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2012 Daniel Silverstone <dsilvers@netsurf-browser.org> |
| */ |
| #ifndef dom_internal_html_text_area_element_h_ |
| #define dom_internal_html_text_area_element_h_ |
| #include <dom/html/html_text_area_element.h> |
| #include "html/html_element.h" |
| struct dom_html_text_area_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| struct dom_html_form_element *form; |
| /**< The form associated with the text_area */ |
| dom_string *default_value; /**< Initial value */ |
| bool default_value_set; /**< Whether default_value has been set */ |
| dom_string *value; /**< Current value */ |
| bool value_set; /**< Whether value has been set */ |
| }; |
| /* Create a dom_html_text_area_element object */ |
| dom_exception _dom_html_text_area_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_text_area_element **ele); |
| /* Initialise a dom_html_text_area_element object */ |
| dom_exception _dom_html_text_area_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_text_area_element *ele); |
| /* Finalise a dom_html_text_area_element object */ |
| void _dom_html_text_area_element_finalise(struct dom_html_text_area_element *ele); |
| /* Destroy a dom_html_text_area_element object */ |
| void _dom_html_text_area_element_destroy(struct dom_html_text_area_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_text_area_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_text_area_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_text_area_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_TEXT_AREA_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_text_area_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_TEXT_AREA_ELEMENT \ |
| _dom_virtual_html_text_area_element_destroy, \ |
| _dom_html_text_area_element_copy |
| /* Internal function for bindings */ |
| dom_exception _dom_html_text_area_element_set_form( |
| dom_html_text_area_element *text_area, dom_html_form_element *form); |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_title_element.c |
|---|
| 0,0 → 1,164 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <dom/core/characterdata.h> |
| #include <dom/core/text.h> |
| #include "html/html_document.h" |
| #include "html/html_title_element.h" |
| #include "core/node.h" |
| #include "utils/utils.h" |
| static struct dom_element_protected_vtable _protect_vtable = { |
| { |
| DOM_NODE_PROTECT_VTABLE_HTML_TITLE_ELEMENT |
| }, |
| DOM_HTML_TITLE_ELEMENT_PROTECT_VTABLE |
| }; |
| /** |
| * Create a dom_html_title_element object |
| * |
| * \param doc The document object |
| * \param ele The returned element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_title_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_title_element **ele) |
| { |
| struct dom_node_internal *node; |
| *ele = malloc(sizeof(dom_html_title_element)); |
| if (*ele == NULL) |
| return DOM_NO_MEM_ERR; |
| /* Set up vtables */ |
| node = (struct dom_node_internal *) *ele; |
| node->base.vtable = &_dom_html_element_vtable; |
| node->vtable = &_protect_vtable; |
| return _dom_html_title_element_initialise(doc, namespace, prefix, *ele); |
| } |
| /** |
| * Initialise a dom_html_title_element object |
| * |
| * \param doc The document object |
| * \param ele The dom_html_title_element object |
| * \return DOM_NO_ERR on success, appropriate dom_exception on failure. |
| */ |
| dom_exception _dom_html_title_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_title_element *ele) |
| { |
| return _dom_html_element_initialise(doc, &ele->base, |
| doc->memoised[hds_TITLE], |
| namespace, prefix); |
| } |
| /** |
| * Finalise a dom_html_title_element object |
| * |
| * \param ele The dom_html_title_element object |
| */ |
| void _dom_html_title_element_finalise(struct dom_html_title_element *ele) |
| { |
| _dom_html_element_finalise(&ele->base); |
| } |
| /** |
| * Destroy a dom_html_title_element object |
| * |
| * \param ele The dom_html_title_element object |
| */ |
| void _dom_html_title_element_destroy(struct dom_html_title_element *ele) |
| { |
| _dom_html_title_element_finalise(ele); |
| free(ele); |
| } |
| /*------------------------------------------------------------------------*/ |
| /* The protected virtual functions */ |
| /* The virtual function used to parse attribute value, see src/core/element.c |
| * for detail */ |
| dom_exception _dom_html_title_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed) |
| { |
| UNUSED(ele); |
| UNUSED(name); |
| dom_string_ref(value); |
| *parsed = value; |
| return DOM_NO_ERR; |
| } |
| /* The virtual destroy function, see src/core/node.c for detail */ |
| void _dom_virtual_html_title_element_destroy(dom_node_internal *node) |
| { |
| _dom_html_title_element_destroy((struct dom_html_title_element *) node); |
| } |
| /* The virtual copy function, see src/core/node.c for detail */ |
| dom_exception _dom_html_title_element_copy(dom_node_internal *old, |
| dom_node_internal **copy) |
| { |
| return _dom_html_element_copy(old, copy); |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* Public APIs */ |
| /** |
| * Get the text of title |
| * |
| * \param ele The title element |
| * \param text The returned text |
| * \return DOM_NO_ERR on success, appropriated dom_exception on failure. |
| */ |
| dom_exception dom_html_title_element_get_text(dom_html_title_element *ele, |
| dom_string **text) |
| { |
| dom_node_internal *node = (dom_node_internal *) ele; |
| dom_node_internal *n = node->first_child; |
| /* There should be only one child of title element */ |
| assert(node->first_child == node->last_child); |
| /* And it should be a text node */ |
| assert(n->type == DOM_TEXT_NODE); |
| return dom_characterdata_get_data(n, text); |
| } |
| /** |
| * Set the text of title |
| * |
| * \param ele The title element |
| * \param text The text data to be set |
| * \return DOM_NO_ERR on success, appropriated dom_exception on failure. |
| */ |
| dom_exception dom_html_title_element_set_text(dom_html_title_element *ele, |
| dom_string *text) |
| { |
| dom_node_internal *node = (dom_node_internal *) ele; |
| dom_node_internal *n = node->first_child; |
| /* There should be only one child of title element */ |
| assert(node->first_child == node->last_child); |
| /* And it should be a text node */ |
| assert(n->type == DOM_TEXT_NODE); |
| return dom_characterdata_set_data(n, text); |
| } |
| /contrib/network/netsurf/libdom/src/html/html_title_element.h |
|---|
| 0,0 → 1,52 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku.com> |
| */ |
| #ifndef dom_internal_html_title_element_h_ |
| #define dom_internal_html_title_element_h_ |
| #include <dom/html/html_title_element.h> |
| #include "html/html_element.h" |
| struct dom_html_title_element { |
| struct dom_html_element base; |
| /**< The base class */ |
| }; |
| /* Create a dom_html_title_element object */ |
| dom_exception _dom_html_title_element_create(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_title_element **ele); |
| /* Initialise a dom_html_title_element object */ |
| dom_exception _dom_html_title_element_initialise(struct dom_html_document *doc, |
| dom_string *namespace, dom_string *prefix, |
| struct dom_html_title_element *ele); |
| /* Finalise a dom_html_title_element object */ |
| void _dom_html_title_element_finalise(struct dom_html_title_element *ele); |
| /* Destroy a dom_html_title_element object */ |
| void _dom_html_title_element_destroy(struct dom_html_title_element *ele); |
| /* The protected virtual functions */ |
| dom_exception _dom_html_title_element_parse_attribute(dom_element *ele, |
| dom_string *name, dom_string *value, |
| dom_string **parsed); |
| void _dom_virtual_html_title_element_destroy(dom_node_internal *node); |
| dom_exception _dom_html_title_element_copy(dom_node_internal *old, |
| dom_node_internal **copy); |
| #define DOM_HTML_TITLE_ELEMENT_PROTECT_VTABLE \ |
| _dom_html_title_element_parse_attribute |
| #define DOM_NODE_PROTECT_VTABLE_HTML_TITLE_ELEMENT \ |
| _dom_virtual_html_title_element_destroy, \ |
| _dom_html_title_element_copy |
| #endif |
| /contrib/network/netsurf/libdom/src/html/html_ulist_element.c |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/html/html_ulist_element.h |
|---|
| 0,0 → 1,7 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| /contrib/network/netsurf/libdom/src/utils/Makefile |
|---|
| 0,0 → 1,8 |
| # Sources |
| OBJS := namespace.o hashtable.o character_valid.o validate.o |
| OUTFILE = libo.o |
| CFLAGS += -I ../../include/ -I ../../ -I ../ -I ./ -I /home/sourcerer/kos_src/newenginek/kolibri/include |
| include $(MENUETDEV)/makefiles/Makefile_for_o_lib |
| /contrib/network/netsurf/libdom/src/utils/character_valid.c |
|---|
| 0,0 → 1,219 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include "utils/character_valid.h" |
| #include <assert.h> |
| static const struct xml_char_range base_char_range[] = { {0x41, 0x5a}, |
| {0x61, 0x7a}, {0xc0, 0xd6}, {0xd8, 0xf6}, {0x00f8, 0x00ff}, |
| {0x100, 0x131}, {0x134, 0x13e}, {0x141, 0x148}, {0x14a, 0x17e}, |
| {0x180, 0x1c3}, {0x1cd, 0x1f0}, {0x1f4, 0x1f5}, {0x1fa, 0x217}, |
| {0x250, 0x2a8}, {0x2bb, 0x2c1}, {0x386, 0x386}, {0x388, 0x38a}, |
| {0x38c, 0x38c}, {0x38e, 0x3a1}, {0x3a3, 0x3ce}, {0x3d0, 0x3d6}, |
| {0x3da, 0x3da}, {0x3dc, 0x3dc}, {0x3de, 0x3de}, {0x3e0, 0x3e0}, |
| {0x3e2, 0x3f3}, {0x401, 0x40c}, {0x40e, 0x44f}, {0x451, 0x45c}, |
| {0x45e, 0x481}, {0x490, 0x4c4}, {0x4c7, 0x4c8}, {0x4cb, 0x4cc}, |
| {0x4d0, 0x4eb}, {0x4ee, 0x4f5}, {0x4f8, 0x4f9}, {0x531, 0x556}, |
| {0x559, 0x559}, {0x561, 0x586}, {0x5d0, 0x5ea}, {0x5f0, 0x5f2}, |
| {0x621, 0x63a}, {0x641, 0x64a}, {0x671, 0x6b7}, {0x6ba, 0x6be}, |
| {0x6c0, 0x6ce}, {0x6d0, 0x6d3}, {0x6d5, 0x6d5}, {0x6e5, 0x6e6}, |
| {0x905, 0x939}, {0x93d, 0x93d}, {0x958, 0x961}, {0x985, 0x98c}, |
| {0x98f, 0x990}, {0x993, 0x9a8}, {0x9aa, 0x9b0}, {0x9b2, 0x9b2}, |
| {0x9b6, 0x9b9}, {0x9dc, 0x9dd}, {0x9df, 0x9e1}, {0x9f0, 0x9f1}, |
| {0xa05, 0xa0a}, {0xa0f, 0xa10}, {0xa13, 0xa28}, {0xa2a, 0xa30}, |
| {0xa32, 0xa33}, {0xa35, 0xa36}, {0xa38, 0xa39}, {0xa59, 0xa5c}, |
| {0xa5e, 0xa5e}, {0xa72, 0xa74}, {0xa85, 0xa8b}, {0xa8d, 0xa8d}, |
| {0xa8f, 0xa91}, {0xa93, 0xaa8}, {0xaaa, 0xab0}, {0xab2, 0xab3}, |
| {0xab5, 0xab9}, {0xabd, 0xabd}, {0xae0, 0xae0}, {0xb05, 0xb0c}, |
| {0xb0f, 0xb10}, {0xb13, 0xb28}, {0xb2a, 0xb30}, {0xb32, 0xb33}, |
| {0xb36, 0xb39}, {0xb3d, 0xb3d}, {0xb5c, 0xb5d}, {0xb5f, 0xb61}, |
| {0xb85, 0xb8a}, {0xb8e, 0xb90}, {0xb92, 0xb95}, {0xb99, 0xb9a}, |
| {0xb9c, 0xb9c}, {0xb9e, 0xb9f}, {0xba3, 0xba4}, {0xba8, 0xbaa}, |
| {0xbae, 0xbb5}, {0xbb7, 0xbb9}, {0xc05, 0xc0c}, {0xc0e, 0xc10}, |
| {0xc12, 0xc28}, {0xc2a, 0xc33}, {0xc35, 0xc39}, {0xc60, 0xc61}, |
| {0xc85, 0xc8c}, {0xc8e, 0xc90}, {0xc92, 0xca8}, {0xcaa, 0xcb3}, |
| {0xcb5, 0xcb9}, {0xcde, 0xcde}, {0xce0, 0xce1}, {0xd05, 0xd0c}, |
| {0xd0e, 0xd10}, {0xd12, 0xd28}, {0xd2a, 0xd39}, {0xd60, 0xd61}, |
| {0xe01, 0xe2e}, {0xe30, 0xe30}, {0xe32, 0xe33}, {0xe40, 0xe45}, |
| {0xe81, 0xe82}, {0xe84, 0xe84}, {0xe87, 0xe88}, {0xe8a, 0xe8a}, |
| {0xe8d, 0xe8d}, {0xe94, 0xe97}, {0xe99, 0xe9f}, {0xea1, 0xea3}, |
| {0xea5, 0xea5}, {0xea7, 0xea7}, {0xeaa, 0xeab}, {0xead, 0xeae}, |
| {0xeb0, 0xeb0}, {0xeb2, 0xeb3}, {0xebd, 0xebd}, {0xec0, 0xec4}, |
| {0xf40, 0xf47}, {0xf49, 0xf69}, {0x10a0, 0x10c5}, {0x10d0, 0x10f6}, |
| {0x1100, 0x1100}, {0x1102, 0x1103}, {0x1105, 0x1107}, {0x1109, 0x1109}, |
| {0x110b, 0x110c}, {0x110e, 0x1112}, {0x113c, 0x113c}, {0x113e, 0x113e}, |
| {0x1140, 0x1140}, {0x114c, 0x114c}, {0x114e, 0x114e}, {0x1150, 0x1150}, |
| {0x1154, 0x1155}, {0x1159, 0x1159}, {0x115f, 0x1161}, {0x1163, 0x1163}, |
| {0x1165, 0x1165}, {0x1167, 0x1167}, {0x1169, 0x1169}, {0x116d, 0x116e}, |
| {0x1172, 0x1173}, {0x1175, 0x1175}, {0x119e, 0x119e}, {0x11a8, 0x11a8}, |
| {0x11ab, 0x11ab}, {0x11ae, 0x11af}, {0x11b7, 0x11b8}, {0x11ba, 0x11ba}, |
| {0x11bc, 0x11c2}, {0x11eb, 0x11eb}, {0x11f0, 0x11f0}, {0x11f9, 0x11f9}, |
| {0x1e00, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15}, {0x1f18, 0x1f1d}, |
| {0x1f20, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, {0x1f59, 0x1f59}, |
| {0x1f5b, 0x1f5b}, {0x1f5d, 0x1f5d}, {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, |
| {0x1fb6, 0x1fbc}, {0x1fbe, 0x1fbe}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fcc}, |
| {0x1fd0, 0x1fd3}, {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, |
| {0x1ff6, 0x1ffc}, {0x2126, 0x2126}, {0x212a, 0x212b}, {0x212e, 0x212e}, |
| {0x2180, 0x2182}, {0x3041, 0x3094}, {0x30a1, 0x30fa}, {0x3105, 0x312c}, |
| {0xac00, 0xd7a3} |
| }; |
| const struct xml_char_group base_char_group = { |
| sizeof(base_char_range) / sizeof(base_char_range[0]), |
| base_char_range}; |
| static const struct xml_char_range char_range[] = { {0x100, 0xd7ff}, |
| {0xe000, 0xfffd}, {0x10000, 0x10ffff} |
| }; |
| const struct xml_char_group char_group = { |
| sizeof(char_range) / sizeof(char_range[0]), char_range}; |
| static const struct xml_char_range combining_char_range[] = { {0x300, 0x345}, |
| {0x360, 0x361}, {0x483, 0x486}, {0x591, 0x5a1}, {0x5a3, 0x5b9}, |
| {0x5bb, 0x5bd}, {0x5bf, 0x5bf}, {0x5c1, 0x5c2}, {0x5c4, 0x5c4}, |
| {0x64b, 0x652}, {0x670, 0x670}, {0x6d6, 0x6dc}, {0x6dd, 0x6df}, |
| {0x6e0, 0x6e4}, {0x6e7, 0x6e8}, {0x6ea, 0x6ed}, {0x901, 0x903}, |
| {0x93c, 0x93c}, {0x93e, 0x94c}, {0x94d, 0x94d}, {0x951, 0x954}, |
| {0x962, 0x963}, {0x981, 0x983}, {0x9bc, 0x9bc}, {0x9be, 0x9be}, |
| {0x9bf, 0x9bf}, {0x9c0, 0x9c4}, {0x9c7, 0x9c8}, {0x9cb, 0x9cd}, |
| {0x9d7, 0x9d7}, {0x9e2, 0x9e3}, {0xa02, 0xa02}, {0xa3c, 0xa3c}, |
| {0xa3e, 0xa3e}, {0xa3f, 0xa3f}, {0xa40, 0xa42}, {0xa47, 0xa48}, |
| {0xa4b, 0xa4d}, {0xa70, 0xa71}, {0xa81, 0xa83}, {0xabc, 0xabc}, |
| {0xabe, 0xac5}, {0xac7, 0xac9}, {0xacb, 0xacd}, {0xb01, 0xb03}, |
| {0xb3c, 0xb3c}, {0xb3e, 0xb43}, {0xb47, 0xb48}, {0xb4b, 0xb4d}, |
| {0xb56, 0xb57}, {0xb82, 0xb83}, {0xbbe, 0xbc2}, {0xbc6, 0xbc8}, |
| {0xbca, 0xbcd}, {0xbd7, 0xbd7}, {0xc01, 0xc03}, {0xc3e, 0xc44}, |
| {0xc46, 0xc48}, {0xc4a, 0xc4d}, {0xc55, 0xc56}, {0xc82, 0xc83}, |
| {0xcbe, 0xcc4}, {0xcc6, 0xcc8}, {0xcca, 0xccd}, {0xcd5, 0xcd6}, |
| {0xd02, 0xd03}, {0xd3e, 0xd43}, {0xd46, 0xd48}, {0xd4a, 0xd4d}, |
| {0xd57, 0xd57}, {0xe31, 0xe31}, {0xe34, 0xe3a}, {0xe47, 0xe4e}, |
| {0xeb1, 0xeb1}, {0xeb4, 0xeb9}, {0xebb, 0xebc}, {0xec8, 0xecd}, |
| {0xf18, 0xf19}, {0xf35, 0xf35}, {0xf37, 0xf37}, {0xf39, 0xf39}, |
| {0xf3e, 0xf3e}, {0xf3f, 0xf3f}, {0xf71, 0xf84}, {0xf86, 0xf8b}, |
| {0xf90, 0xf95}, {0xf97, 0xf97}, {0xf99, 0xfad}, {0xfb1, 0xfb7}, |
| {0xfb9, 0xfb9}, {0x20d0, 0x20dc}, {0x20e1, 0x20e1}, {0x302a, 0x302f}, |
| {0x3099, 0x3099}, {0x309a, 0x309a} |
| }; |
| const struct xml_char_group combining_char_group = { |
| sizeof(combining_char_range) / sizeof(combining_char_range[0]), |
| combining_char_range }; |
| static const struct xml_char_range digit_char_range[] = { {0x30, 0x39}, |
| {0x660, 0x669}, {0x6f0, 0x6f9}, {0x966, 0x96f}, {0x9e6, 0x9ef}, |
| {0xa66, 0xa6f}, {0xae6, 0xaef}, {0xb66, 0xb6f}, {0xbe7, 0xbef}, |
| {0xc66, 0xc6f}, {0xce6, 0xcef}, {0xd66, 0xd6f}, {0xe50, 0xe59}, |
| {0xed0, 0xed9}, {0xf20, 0xf29} |
| }; |
| const struct xml_char_group digit_char_group = { |
| sizeof(digit_char_range) / sizeof(digit_char_range[0]), |
| digit_char_range }; |
| static const struct xml_char_range extender_range[] = { {0xb7, 0xb7}, |
| {0x2d0, 0x2d0}, {0x2d1, 0x2d1}, {0x387, 0x387}, {0x640, 0x640}, |
| {0xe46, 0xe46}, {0xec6, 0xec6}, {0x3005, 0x3005}, {0x3031, 0x3035}, |
| {0x309d, 0x309e}, {0x30fc, 0x30fe} |
| }; |
| const struct xml_char_group extender_group = { |
| sizeof(extender_range) / sizeof(extender_range[0]), |
| extender_range }; |
| static const struct xml_char_range ideographic_range[] = { {0x3007, 0x3007}, |
| {0x3021, 0x3029}, {0x4e00, 0x9fa5} |
| }; |
| const struct xml_char_group ideographic_group = { |
| sizeof(ideographic_range) / sizeof(ideographic_range[0]), |
| ideographic_range }; |
| /* The binary search helper function */ |
| static bool binary_search(unsigned int ch, int left, int right, |
| const struct xml_char_range *range); |
| /* Search for ch in range[left, right] */ |
| bool binary_search(unsigned int ch, int left, int right, |
| const struct xml_char_range *range) |
| { |
| int mid; |
| if (left > right) |
| return false; |
| mid = (left + right) / 2; |
| if (ch >= range[mid].start && ch <= range[mid].end) |
| return true; |
| if (ch < range[mid].start) |
| return binary_search(ch, left, mid - 1, range); |
| if (ch > range[mid].end) |
| return binary_search(ch, mid + 1, right, range); |
| return false; |
| } |
| /** |
| * Test whether certain character beint32_ts to some XML character group |
| * |
| * \param ch The character being tested |
| * \param group The character group |
| * \return true if the character beint32_ts to the group, false otherwise. |
| * |
| * Generally, we use an algorithm like binary search to find the desired |
| * character in the group. The time complexity is about lg(n) and here n is |
| * at most 180, so, I think the algorithm is fast enough for name validation. |
| */ |
| bool _dom_is_character_in_group(unsigned int ch, |
| const struct xml_char_group *group) |
| { |
| int len = group->len; |
| const struct xml_char_range *range = group->range; |
| if (ch < range[0].start || ch > range[len-1].end) |
| return false; |
| return binary_search(ch, 0, len - 1, range); |
| } |
| #ifdef CHVALID_DEBUG |
| /* The following is the testcases for this file. |
| * Compile this file : |
| * |
| * gcc -o test -DCHVALID_DEBUG character_valid.c |
| * |
| */ |
| #include <stdio.h> |
| int main(int argc, char **argv) |
| { |
| unsigned int ch = 0x666; |
| assert(is_digit(ch) == true); |
| assert(is_base_char(ch) == false); |
| assert(is_char(ch) == true); |
| assert(is_extender(ch) == false); |
| assert(is_combining_char(ch) == false); |
| assert(is_ideographic(ch) == false); |
| ch = 0xf40; |
| assert(is_digit(ch) == false); |
| assert(is_base_char(ch) == true); |
| assert(is_char(ch) == true); |
| assert(is_extender(ch) == false); |
| assert(is_combining_char(ch) == false); |
| assert(is_ideographic(ch) == false); |
| printf("The test pass.\n"); |
| return 0; |
| } |
| #endif |
| /contrib/network/netsurf/libdom/src/utils/character_valid.h |
|---|
| 0,0 → 1,54 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| * |
| * This file contains the API used to validate whether certain character in |
| * name/value is legal according the XML 1.0 standard. See |
| * |
| * http://www.w3.org/TR/2004/REC-xml-20040204/ |
| * http://www.w3.org/TR/REC-xml/ |
| * |
| * for detail. |
| */ |
| #ifndef dom_utils_character_valid_h_ |
| #define dom_utils_character_valid_h_ |
| #include <stdbool.h> |
| #include <stdlib.h> |
| struct xml_char_range { |
| unsigned int start; |
| unsigned int end; |
| }; |
| struct xml_char_group { |
| size_t len; |
| const struct xml_char_range *range; |
| }; |
| /* The groups */ |
| extern const struct xml_char_group base_char_group; |
| extern const struct xml_char_group char_group; |
| extern const struct xml_char_group combining_char_group; |
| extern const struct xml_char_group digit_char_group; |
| extern const struct xml_char_group extender_group; |
| extern const struct xml_char_group ideographic_group; |
| bool _dom_is_character_in_group(unsigned int ch, |
| const struct xml_char_group *group); |
| #define is_base_char(ch) _dom_is_character_in_group((ch), &base_char_group) |
| #define is_char(ch) _dom_is_character_in_group((ch), &char_group) |
| #define is_combining_char(ch) _dom_is_character_in_group((ch), \ |
| &combining_char_group) |
| #define is_digit(ch) _dom_is_character_in_group((ch), &digit_char_group) |
| #define is_extender(ch) _dom_is_character_in_group((ch), &extender_group) |
| #define is_ideographic(ch) _dom_is_character_in_group((ch), &ideographic_group) |
| #define is_letter(ch) (is_base_char(ch) || is_ideographic(ch)) |
| #endif |
| /contrib/network/netsurf/libdom/src/utils/hashtable.c |
|---|
| 0,0 → 1,444 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2006 Rob Kendrick <rjek@rjek.com> |
| * Copyright 2006 Richard Wilson <info@tinct.net> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| typedef unsigned char uint8_t; |
| typedef unsigned short uint16_t; |
| typedef unsigned int uint32_t; |
| #include <stdlib.h> |
| #include <string.h> |
| #include <stdbool.h> |
| #include <assert.h> |
| #ifdef TEST_RIG |
| #include <stdio.h> |
| #endif |
| #include "utils/hashtable.h" |
| #include <libwapcaplet/libwapcaplet.h> |
| /* The hash table entry */ |
| struct _dom_hash_entry { |
| void *key; /**< The key pointer */ |
| void *value; /**< The value pointer */ |
| struct _dom_hash_entry *next; /**< Next entry */ |
| }; |
| /* The hash table */ |
| struct dom_hash_table { |
| const dom_hash_vtable *vtable; /**< Vtable */ |
| void *pw; /**< Client data */ |
| unsigned int nchains; /**< Number of chains */ |
| struct _dom_hash_entry **chain; /**< The chain head */ |
| uint32_t nentries; /**< The entries in this table */ |
| }; |
| /** |
| * Create a new hash table, and return a context for it. The memory consumption |
| * of a hash table is approximately 8 + (nchains * 12) bytes if it is empty. |
| * |
| * \param chains Number of chains/buckets this hash table will have. This |
| * should be a prime number, and ideally a prime number just |
| * over a power of two, for best performance and distribution |
| * \param vtable Client vtable |
| * \param pw Client private data |
| * \return struct dom_hash_table containing the context of this hash table or |
| * NULL if there is insufficent memory to create it and its chains. |
| */ |
| dom_hash_table *_dom_hash_create(unsigned int chains, |
| const dom_hash_vtable *vtable, void *pw) |
| { |
| dom_hash_table *r = malloc(sizeof(struct dom_hash_table)); |
| if (r == NULL) { |
| return NULL; |
| } |
| r->vtable = vtable; |
| r->pw = pw; |
| r->nentries = 0; |
| r->nchains = chains; |
| r->chain = calloc(chains, sizeof(struct _dom_hash_entry *)); |
| if (r->chain == NULL) { |
| free(r); |
| return NULL; |
| } |
| return r; |
| } |
| /** |
| * Clone a hash table. |
| * |
| * \param ht Hash table to clone. |
| * |
| * \return The cloned hash table. |
| */ |
| dom_hash_table *_dom_hash_clone(dom_hash_table *ht) |
| { |
| void *key = NULL, *nkey = NULL; |
| void *value = NULL, *nvalue = NULL; |
| uintptr_t c1, *c2 = NULL; |
| struct dom_hash_table *ret; |
| ret = _dom_hash_create(ht->nchains, ht->vtable, ht->pw); |
| if (ret == NULL) |
| return NULL; |
| while ( (key = _dom_hash_iterate(ht, &c1, &c2)) != NULL) { |
| nkey = ht->vtable->clone_key(key, ht->pw); |
| if (nkey == NULL) { |
| _dom_hash_destroy(ret); |
| return NULL; |
| } |
| value = _dom_hash_get(ht, key); |
| nvalue = ht->vtable->clone_value(value, ht->pw); |
| if (nvalue == NULL) { |
| ht->vtable->destroy_key(nkey, ht->pw); |
| _dom_hash_destroy(ret); |
| return NULL; |
| } |
| if (_dom_hash_add(ret, nkey, nvalue, false) == false) { |
| _dom_hash_destroy(ret); |
| return NULL; |
| } |
| } |
| return ret; |
| } |
| /** |
| * Destroys a hash table, freeing all memory associated with it. |
| * |
| * \param ht Hash table to destroy. After the function returns, this |
| * will nolonger be valid |
| */ |
| void _dom_hash_destroy(dom_hash_table *ht) |
| { |
| unsigned int i; |
| if (ht == NULL) |
| return; |
| for (i = 0; i < ht->nchains; i++) { |
| if (ht->chain[i] != NULL) { |
| struct _dom_hash_entry *e = ht->chain[i]; |
| while (e) { |
| struct _dom_hash_entry *n = e->next; |
| ht->vtable->destroy_key(e->key, ht->pw); |
| ht->vtable->destroy_value(e->value, ht->pw); |
| free(e); |
| e = n; |
| } |
| } |
| } |
| free(ht->chain); |
| free(ht); |
| } |
| /** |
| * Adds a key/value pair to a hash table |
| * |
| * \param ht The hash table context to add the key/value pair to. |
| * \param key The key to associate the value with. |
| * \param value The value to associate the key with. |
| * \return true if the add succeeded, false otherwise. (Failure most likely |
| * indicates insufficent memory to make copies of the key and value. |
| */ |
| bool _dom_hash_add(dom_hash_table *ht, void *key, void *value, |
| bool replace) |
| { |
| unsigned int h, c; |
| struct _dom_hash_entry *e; |
| if (ht == NULL || key == NULL || value == NULL) |
| return false; |
| h = ht->vtable->hash(key, ht->pw); |
| c = h % ht->nchains; |
| for (e = ht->chain[c]; e; e = e->next) { |
| if (ht->vtable->key_isequal(key, e->key, ht->pw)) { |
| if (replace == true) { |
| e->value = value; |
| return true; |
| } else { |
| return false; |
| } |
| } |
| } |
| e = malloc(sizeof(struct _dom_hash_entry)); |
| if (e == NULL) { |
| return false; |
| } |
| e->key = key; |
| e->value = value; |
| e->next = ht->chain[c]; |
| ht->chain[c] = e; |
| ht->nentries++; |
| return true; |
| } |
| /** |
| * Looks up a the value associated with with a key from a specific hash table. |
| * |
| * \param ht The hash table context to look up |
| * \param key The key to search for |
| * \return The value associated with the key, or NULL if it was not found. |
| */ |
| void *_dom_hash_get(struct dom_hash_table *ht, void *key) |
| { |
| unsigned int h, c; |
| struct _dom_hash_entry *e; |
| if (ht == NULL || key == NULL) |
| return NULL; |
| h = ht->vtable->hash(key, ht->pw); |
| c = h % ht->nchains; |
| for (e = ht->chain[c]; e; e = e->next) { |
| if (ht->vtable->key_isequal(key, e->key, ht->pw)) |
| return e->value; |
| } |
| return NULL; |
| } |
| /** |
| * Delete the key from the hashtable. |
| * |
| * \param ht The hashtable object |
| * \param key The key to delete |
| * \return The deleted value |
| */ |
| void *_dom_hash_del(struct dom_hash_table *ht, void *key) |
| { |
| unsigned int h, c; |
| struct _dom_hash_entry *e, *p; |
| void *ret; |
| if (ht == NULL || key == NULL) |
| return NULL; |
| h = ht->vtable->hash(key, ht->pw); |
| c = h % ht->nchains; |
| p = ht->chain[c]; |
| for (e = p; e; p = e, e = e->next) { |
| if (ht->vtable->key_isequal(key, e->key, ht->pw)) { |
| if (p != e) { |
| p->next = e->next; |
| } else { |
| /* The first item in this chain is target*/ |
| ht->chain[c] = e->next; |
| } |
| ret = e->value; |
| free(e); |
| ht->nentries--; |
| return ret; |
| } |
| } |
| return NULL; |
| } |
| /** |
| * Iterate through all available hash keys. |
| * |
| * \param ht The hash table context to iterate. |
| * \param c1 Pointer to first context |
| * \param c2 Pointer to second context (set to 0 on first call) |
| * \return The next hash key, or NULL for no more keys |
| */ |
| void *_dom_hash_iterate(struct dom_hash_table *ht, unsigned long int *c1, |
| unsigned long int **c2) |
| { |
| struct _dom_hash_entry **he = (struct _dom_hash_entry **) c2; |
| if (ht == NULL) |
| return NULL; |
| if (!*he) |
| *c1 = -1; |
| else |
| *he = (*he)->next; |
| if (*he) |
| return (*he)->key; |
| while (!*he) { |
| (*c1)++; |
| if (*c1 >= ht->nchains) |
| return NULL; |
| *he = ht->chain[*c1]; |
| } |
| return (*he)->key; |
| } |
| /** |
| * Get the number of elements in this hash table |
| * |
| * \param ht The hash table |
| * |
| * \return the number of elements |
| */ |
| uint32_t _dom_hash_get_length(struct dom_hash_table *ht) |
| { |
| return ht->nentries; |
| } |
| /*-----------------------------------------------------------------------*/ |
| /* A simple test rig. To compile, use: |
| * gcc -g -o hashtest -I../ -I../../include -DTEST_RIG hashtable.c |
| * |
| * If you make changes to this hash table implementation, please rerun this |
| * test, and if possible, through valgrind to make sure there are no memory |
| * leaks or invalid memory accesses. If you add new functionality, please |
| * include a test for it that has good coverage along side the other tests. |
| */ |
| #ifdef TEST_RIG |
| /** |
| * Hash a pointer, returning a 32bit value. |
| * |
| * \param ptr The pointer to hash. |
| * \return the calculated hash value for the pointer. |
| */ |
| static inline unsigned int _dom_hash_pointer_fnv(void *ptr) |
| { |
| return (unsigned int) ptr; |
| } |
| static void *test_alloc(void *p, size_t size, void *ptr) |
| { |
| if (p != NULL) { |
| free(p); |
| return NULL; |
| } |
| if (p == NULL) { |
| return malloc(size); |
| } |
| } |
| int main(int argc, char *argv[]) |
| { |
| struct dom_hash_table *a, *b; |
| FILE *dict; |
| char keybuf[BUFSIZ], valbuf[BUFSIZ]; |
| int i; |
| char *cow="cow", *moo="moo", *pig="pig", *oink="oink", |
| *chicken="chikcken", *cluck="cluck", |
| *dog="dog", *woof="woof", *cat="cat", |
| *meow="meow"; |
| void *ret; |
| a = _dom_hash_create(79, _dom_hash_pointer_fnv, test_alloc, NULL); |
| assert(a != NULL); |
| b = _dom_hash_create(103, _dom_hash_pointer_fnv, test_alloc, NULL); |
| assert(b != NULL); |
| _dom_hash_add(a, cow, moo ,true); |
| _dom_hash_add(b, moo, cow ,true); |
| _dom_hash_add(a, pig, oink ,true); |
| _dom_hash_add(b, oink, pig ,true); |
| _dom_hash_add(a, chicken, cluck ,true); |
| _dom_hash_add(b, cluck, chicken ,true); |
| _dom_hash_add(a, dog, woof ,true); |
| _dom_hash_add(b, woof, dog ,true); |
| _dom_hash_add(a, cat, meow ,true); |
| _dom_hash_add(b, meow, cat ,true); |
| #define MATCH(x,y) assert(!strcmp((char *)hash_get(a, x), (char *)y)); \ |
| assert(!strcmp((char *)hash_get(b, y), (char *)x)) |
| MATCH(cow, moo); |
| MATCH(pig, oink); |
| MATCH(chicken, cluck); |
| MATCH(dog, woof); |
| MATCH(cat, meow); |
| assert(hash_get_length(a) == 5); |
| assert(hash_get_length(b) == 5); |
| _dom_hash_del(a, cat); |
| _dom_hash_del(b, meow); |
| assert(hash_get(a, cat) == NULL); |
| assert(hash_get(b, meow) == NULL); |
| assert(hash_get_length(a) == 4); |
| assert(hash_get_length(b) == 4); |
| _dom_hash_destroy(a, NULL, NULL); |
| _dom_hash_destroy(b, NULL, NULL); |
| /* This test requires /usr/share/dict/words - a large list of English |
| * words. We load the entire file - odd lines are used as keys, and |
| * even lines are used as the values for the previous line. we then |
| * work through it again making sure everything matches. |
| * |
| * We do this twice - once in a hash table with many chains, and once |
| * with a hash table with fewer chains. |
| */ |
| a = _dom_hash_create(1031, _dom_hash_pointer_fnv, test_alloc, NULL); |
| b = _dom_hash_create(7919, _dom_hash_pointer_fnv, test_alloc, NULL); |
| dict = fopen("/usr/share/dict/words", "r"); |
| if (dict == NULL) { |
| fprintf(stderr, "Unable to open /usr/share/dict/words - \ |
| extensive testing skipped.\n"); |
| exit(0); |
| } |
| while (!feof(dict)) { |
| fscanf(dict, "%s", keybuf); |
| fscanf(dict, "%s", valbuf); |
| _dom_hash_add(a, keybuf, valbuf, true); |
| _dom_hash_add(b, keybuf, valbuf, true); |
| } |
| for (i = 0; i < 5; i++) { |
| fseek(dict, 0, SEEK_SET); |
| while (!feof(dict)) { |
| fscanf(dict, "%s", keybuf); |
| fscanf(dict, "%s", valbuf); |
| assert(strcmp(hash_get(a, keybuf), valbuf) == 0); |
| assert(strcmp(hash_get(b, keybuf), valbuf) == 0); |
| } |
| } |
| _dom_hash_destroy(a, NULL, NULL); |
| _dom_hash_destroy(b, NULL, NULL); |
| fclose(dict); |
| return 0; |
| } |
| #endif |
| /contrib/network/netsurf/libdom/src/utils/hashtable.h |
|---|
| 0,0 → 1,37 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2006 Rob Kendrick <rjek@rjek.com> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef dom_utils_hashtable_h_ |
| #define dom_utils_hashtable_h_ |
| #include <stdbool.h> |
| #include <dom/functypes.h> |
| typedef struct dom_hash_table dom_hash_table; |
| typedef struct dom_hash_vtable { |
| uint32_t (*hash)(void *key, void *pw); |
| void *(*clone_key)(void *key, void *pw); |
| void (*destroy_key)(void *key, void *pw); |
| void *(*clone_value)(void *value, void *pw); |
| void (*destroy_value)(void *value, void *pw); |
| bool (*key_isequal)(void *key1, void *key2, void *pw); |
| } dom_hash_vtable; |
| dom_hash_table *_dom_hash_create(unsigned int chains, |
| const dom_hash_vtable *vtable, void *pw); |
| dom_hash_table *_dom_hash_clone(dom_hash_table *ht); |
| void _dom_hash_destroy(dom_hash_table *ht); |
| bool _dom_hash_add(dom_hash_table *ht, void *key, void *value, |
| bool replace); |
| void *_dom_hash_get(dom_hash_table *ht, void *key); |
| void *_dom_hash_del(dom_hash_table *ht, void *key); |
| void *_dom_hash_iterate(dom_hash_table *ht, unsigned long int *c1, unsigned long int **c2); |
| uint32_t _dom_hash_get_length(dom_hash_table *ht); |
| #endif |
| /contrib/network/netsurf/libdom/src/utils/list.h |
|---|
| 0,0 → 1,61 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| * |
| * This file contains the list structure used to compose lists. |
| * |
| * Note: This is a implementation of a doubld-linked cyclar list. |
| */ |
| #ifndef dom_utils_list_h_ |
| #define dom_utils_list_h_ |
| #include <stddef.h> |
| struct list_entry { |
| struct list_entry *prev; |
| struct list_entry *next; |
| }; |
| /** |
| * Initialise a list_entry structure |
| * |
| * \param ent The entry to initialise |
| */ |
| static inline void list_init(struct list_entry *ent) |
| { |
| ent->prev = ent; |
| ent->next = ent; |
| } |
| /** |
| * Append a new list_entry after the list |
| * |
| * \param head The list header |
| * \param new The new entry |
| */ |
| static inline void list_append(struct list_entry *head, struct list_entry *new) |
| { |
| new->next = head; |
| new->prev = head->prev; |
| head->prev->next = new; |
| head->prev = new; |
| } |
| /** |
| * Delete a list_entry from the list |
| * |
| * \param entry The entry need to be deleted from the list |
| */ |
| static inline void list_del(struct list_entry *ent) |
| { |
| ent->prev->next = ent->next; |
| ent->next->prev = ent->prev; |
| ent->prev = ent; |
| ent->next = ent; |
| } |
| #endif |
| /contrib/network/netsurf/libdom/src/utils/namespace.c |
|---|
| 0,0 → 1,329 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <string.h> |
| typedef unsigned int uint32_t; |
| #include <dom/dom.h> |
| #include "utils/namespace.h" |
| #include "utils/validate.h" |
| #include "utils/utils.h" |
| /** XML prefix */ |
| static dom_string *xml; |
| /** XMLNS prefix */ |
| static dom_string *xmlns; |
| /* The namespace strings */ |
| static const char *namespaces[DOM_NAMESPACE_COUNT] = { |
| NULL, |
| "http://www.w3.org/1999/xhtml", |
| "http://www.w3.org/1998/Math/MathML", |
| "http://www.w3.org/2000/svg", |
| "http://www.w3.org/1999/xlink", |
| "http://www.w3.org/XML/1998/namespace", |
| "http://www.w3.org/2000/xmlns/" |
| }; |
| dom_string *dom_namespaces[DOM_NAMESPACE_COUNT] = { |
| NULL, |
| }; |
| /** |
| * Initialise the namespace component |
| * |
| * \return DOM_NO_ERR on success. |
| */ |
| static dom_exception _dom_namespace_initialise(void) |
| { |
| int i; |
| dom_exception err; |
| err = dom_string_create((const uint8_t *) "xml", SLEN("xml"), &xml); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| err = dom_string_create((const uint8_t *) "xmlns", SLEN("xmlns"), |
| &xmlns); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(xml); |
| xml = NULL; |
| return err; |
| } |
| for (i = 1; i < DOM_NAMESPACE_COUNT; i++) { |
| err = dom_string_create( |
| (const uint8_t *) namespaces[i], |
| strlen(namespaces[i]), &dom_namespaces[i]); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(xmlns); |
| xmlns = NULL; |
| dom_string_unref(xml); |
| xml = NULL; |
| return err; |
| } |
| } |
| return DOM_NO_ERR; |
| } |
| #ifdef FINALISE_NAMESPACE |
| /** |
| * Finalise the namespace component |
| * |
| * \return DOM_NO_ERR on success. |
| */ |
| dom_exception _dom_namespace_finalise(void) |
| { |
| int i; |
| if (xmlns != NULL) { |
| dom_string_unref(xmlns); |
| xmlns = NULL; |
| } |
| if (xml != NULL) { |
| dom_string_unref(xml); |
| xml = NULL; |
| } |
| for (i = 1; i < DOM_NAMESPACE_COUNT; i++) { |
| if (dom_namespaces[i] != NULL) { |
| dom_string_unref(dom_namespaces[i]); |
| dom_namespaces[i] = NULL; |
| } |
| } |
| return DOM_NO_ERR; |
| } |
| #endif |
| /** |
| * Ensure a QName is valid |
| * |
| * \param qname The qname to validate |
| * \param namespace The namespace URI associated with the QName, or NULL |
| * \return DOM_NO_ERR if valid, |
| * DOM_INVALID_CHARACTER_ERR if ::qname contains an invalid character, |
| * DOM_NAMESPACE_ERR if ::qname is malformed, or it has a |
| * prefix and ::namespace is NULL, or |
| * ::qname has a prefix "xml" and |
| * ::namespace is not |
| * "http://www.w3.org/XML/1998/namespace", |
| * or ::qname has a prefix "xmlns" and |
| * ::namespace is not |
| * "http://www.w3.org/2000/xmlns", or |
| * ::namespace is |
| * "http://www.w3.org/2000/xmlns" and |
| * ::qname is not (or is not prefixed by) |
| * "xmlns". |
| */ |
| dom_exception _dom_namespace_validate_qname(dom_string *qname, |
| dom_string *namespace) |
| { |
| uint32_t colon, len; |
| if (xml == NULL) { |
| dom_exception err = _dom_namespace_initialise(); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| if (qname == NULL) { |
| if (namespace != NULL) |
| return DOM_NAMESPACE_ERR; |
| if (namespace == NULL) |
| return DOM_NO_ERR; |
| } |
| if (_dom_validate_name(qname) == false) |
| return DOM_NAMESPACE_ERR; |
| len = dom_string_length(qname); |
| /* Find colon */ |
| colon = dom_string_index(qname, ':'); |
| if (colon == (uint32_t) -1) { |
| /* No prefix */ |
| /* If namespace URI is for xmlns, ensure qname == "xmlns" */ |
| if (namespace != NULL && |
| dom_string_isequal(namespace, |
| dom_namespaces[DOM_NAMESPACE_XMLNS]) && |
| dom_string_isequal(qname, xmlns) == false) { |
| return DOM_NAMESPACE_ERR; |
| } |
| /* If qname == "xmlns", ensure namespace URI is for xmlns */ |
| if (namespace != NULL && |
| dom_string_isequal(qname, xmlns) && |
| dom_string_isequal(namespace, |
| dom_namespaces[DOM_NAMESPACE_XMLNS]) == false) { |
| return DOM_NAMESPACE_ERR; |
| } |
| } else if (colon == 0) { |
| /* Some name like ":name" */ |
| if (namespace != NULL) |
| return DOM_NAMESPACE_ERR; |
| } else { |
| /* Prefix */ |
| dom_string *prefix; |
| dom_string *lname; |
| dom_exception err; |
| /* Ensure there is a namespace URI */ |
| if (namespace == NULL) { |
| return DOM_NAMESPACE_ERR; |
| } |
| err = dom_string_substr(qname, 0, colon, &prefix); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| err = dom_string_substr(qname, colon + 1, len, &lname); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| if (_dom_validate_ncname(prefix) == false || |
| _dom_validate_ncname(lname) == false) { |
| return DOM_NAMESPACE_ERR; |
| } |
| /* Test for invalid XML namespace */ |
| if (dom_string_isequal(prefix, xml) && |
| dom_string_isequal(namespace, |
| dom_namespaces[DOM_NAMESPACE_XML]) == false) { |
| dom_string_unref(prefix); |
| return DOM_NAMESPACE_ERR; |
| } |
| /* Test for invalid xmlns namespace */ |
| if (dom_string_isequal(prefix, xmlns) && |
| dom_string_isequal(namespace, |
| dom_namespaces[DOM_NAMESPACE_XMLNS]) == false) { |
| dom_string_unref(prefix); |
| return DOM_NAMESPACE_ERR; |
| } |
| /* Test for presence of xmlns namespace with non xmlns prefix */ |
| if (dom_string_isequal(namespace, |
| dom_namespaces[DOM_NAMESPACE_XMLNS]) && |
| dom_string_isequal(prefix, xmlns) == false) { |
| dom_string_unref(prefix); |
| return DOM_NAMESPACE_ERR; |
| } |
| dom_string_unref(prefix); |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Split a QName into a namespace prefix and localname string |
| * |
| * \param qname The qname to split |
| * \param prefix Pointer to location to receive prefix |
| * \param localname Pointer to location to receive localname |
| * \return DOM_NO_ERR on success. |
| * |
| * If there is no prefix present in ::qname, then ::prefix will be NULL. |
| * |
| * ::prefix and ::localname will be referenced. The caller should unreference |
| * them once finished. |
| */ |
| dom_exception _dom_namespace_split_qname(dom_string *qname, |
| dom_string **prefix, dom_string **localname) |
| { |
| uint32_t colon; |
| dom_exception err; |
| if (xml == NULL) { |
| err = _dom_namespace_initialise(); |
| if (err != DOM_NO_ERR) |
| return err; |
| } |
| /* Find colon, if any */ |
| colon = dom_string_index(qname, ':'); |
| if (colon == (uint32_t) -1) { |
| /* None found => no prefix */ |
| *prefix = NULL; |
| *localname = dom_string_ref(qname); |
| } else { |
| /* Found one => prefix */ |
| err = dom_string_substr(qname, 0, colon, prefix); |
| if (err != DOM_NO_ERR) { |
| return err; |
| } |
| err = dom_string_substr(qname, colon + 1, |
| dom_string_length(qname), localname); |
| if (err != DOM_NO_ERR) { |
| dom_string_unref(*prefix); |
| *prefix = NULL; |
| return err; |
| } |
| } |
| return DOM_NO_ERR; |
| } |
| /** |
| * Get the XML prefix dom_string |
| * |
| * \return the xml prefix dom_string. |
| * |
| * Note: The client of this function may or may not call the dom_string_ref |
| * on the returned dom_string, because this string will only be destroyed when |
| * the dom_finalise is called. But if the client call dom_string_ref, it must |
| * call dom_string_unref to maintain a correct ref count of the dom_string. |
| */ |
| dom_string *_dom_namespace_get_xml_prefix(void) |
| { |
| if (xml == NULL) { |
| if (_dom_namespace_initialise() != DOM_NO_ERR) |
| return NULL; |
| } |
| return xml; |
| } |
| /** |
| * Get the XMLNS prefix dom_string. |
| * |
| * \return the xmlns prefix dom_string |
| * |
| * Note: The client of this function may or may not call the dom_string_ref |
| * on the returned dom_string, because this string will only be destroyed when |
| * the dom_finalise is called. But if the client call dom_string_ref, it must |
| * call dom_string_unref to maintain a correct ref count of the dom_string. |
| */ |
| dom_string *_dom_namespace_get_xmlns_prefix(void) |
| { |
| if (xml == NULL) { |
| if (_dom_namespace_initialise() != DOM_NO_ERR) |
| return NULL; |
| } |
| return xmlns; |
| } |
| /contrib/network/netsurf/libdom/src/utils/namespace.h |
|---|
| 0,0 → 1,32 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_utils_namespace_h_ |
| #define dom_utils_namespace_h_ |
| #include <dom/functypes.h> |
| #include <dom/core/exceptions.h> |
| #include <dom/core/string.h> |
| struct dom_document; |
| /* Ensure a QName is valid */ |
| dom_exception _dom_namespace_validate_qname(dom_string *qname, |
| dom_string *namespace); |
| /* Split a QName into a namespace prefix and localname string */ |
| dom_exception _dom_namespace_split_qname(dom_string *qname, |
| dom_string **prefix, dom_string **localname); |
| /* Get the XML prefix dom_string */ |
| dom_string *_dom_namespace_get_xml_prefix(void); |
| /* Get the XMLNS prefix dom_string */ |
| dom_string *_dom_namespace_get_xmlns_prefix(void); |
| #endif |
| /contrib/network/netsurf/libdom/src/utils/utils.h |
|---|
| 0,0 → 1,28 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef dom_utils_utils_h_ |
| #define dom_utils_utils_h_ |
| #ifndef max |
| #define max(a,b) ((a)>(b)?(a):(b)) |
| #endif |
| #ifndef min |
| #define min(a,b) ((a)<(b)?(a):(b)) |
| #endif |
| #ifndef SLEN |
| /* Calculate length of a string constant */ |
| #define SLEN(s) (sizeof((s)) - 1) /* -1 for '\0' */ |
| #endif |
| #ifndef UNUSED |
| #define UNUSED(x) ((x)=(x)) |
| #endif |
| #endif |
| /contrib/network/netsurf/libdom/src/utils/validate.c |
|---|
| 0,0 → 1,201 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <inttypes.h> |
| #include <stddef.h> |
| #include "utils/validate.h" |
| #include <dom/core/string.h> |
| #include "utils/character_valid.h" |
| #include "utils/namespace.h" |
| #include "utils/utils.h" |
| #include <parserutils/charset/utf8.h> |
| /* An combination of various tests */ |
| static bool is_first_char(uint32_t ch); |
| static bool is_name_char(uint32_t ch); |
| /* Test whether the character can be the first character of |
| * a NCName. */ |
| static bool is_first_char(uint32_t ch) |
| { |
| /* Refer http://www.w3.org/TR/REC-xml/ for detail */ |
| if (((ch >= 'a') && (ch <= 'z')) || |
| ((ch >= 'A') && (ch <= 'Z')) || |
| (ch == '_') || (ch == ':') || |
| ((ch >= 0xC0) && (ch <= 0xD6)) || |
| ((ch >= 0xD8) && (ch <= 0xF6)) || |
| ((ch >= 0xF8) && (ch <= 0x2FF)) || |
| ((ch >= 0x370) && (ch <= 0x37D)) || |
| ((ch >= 0x37F) && (ch <= 0x1FFF)) || |
| ((ch >= 0x200C) && (ch <= 0x200D)) || |
| ((ch >= 0x2070) && (ch <= 0x218F)) || |
| ((ch >= 0x2C00) && (ch <= 0x2FEF)) || |
| ((ch >= 0x3001) && (ch <= 0xD7FF)) || |
| ((ch >= 0xF900) && (ch <= 0xFDCF)) || |
| ((ch >= 0xFDF0) && (ch <= 0xFFFD)) || |
| ((ch >= 0x10000) && (ch <= 0xEFFFF))) |
| return true; |
| if (is_letter(ch) || ch == (uint32_t) '_' || ch == (uint32_t) ':') { |
| return true; |
| } |
| return false; |
| } |
| /* Test whether the character can be a part of a NCName */ |
| static bool is_name_char(uint32_t ch) |
| { |
| /* Refer http://www.w3.org/TR/REC-xml/ for detail */ |
| if (((ch >= 'a') && (ch <= 'z')) || |
| ((ch >= 'A') && (ch <= 'Z')) || |
| ((ch >= '0') && (ch <= '9')) || /* !start */ |
| (ch == '_') || (ch == ':') || |
| (ch == '-') || (ch == '.') || (ch == 0xB7) || /* !start */ |
| ((ch >= 0xC0) && (ch <= 0xD6)) || |
| ((ch >= 0xD8) && (ch <= 0xF6)) || |
| ((ch >= 0xF8) && (ch <= 0x2FF)) || |
| ((ch >= 0x300) && (ch <= 0x36F)) || /* !start */ |
| ((ch >= 0x370) && (ch <= 0x37D)) || |
| ((ch >= 0x37F) && (ch <= 0x1FFF)) || |
| ((ch >= 0x200C) && (ch <= 0x200D)) || |
| ((ch >= 0x203F) && (ch <= 0x2040)) || /* !start */ |
| ((ch >= 0x2070) && (ch <= 0x218F)) || |
| ((ch >= 0x2C00) && (ch <= 0x2FEF)) || |
| ((ch >= 0x3001) && (ch <= 0xD7FF)) || |
| ((ch >= 0xF900) && (ch <= 0xFDCF)) || |
| ((ch >= 0xFDF0) && (ch <= 0xFFFD)) || |
| ((ch >= 0x10000) && (ch <= 0xEFFFF))) |
| return true; |
| if (is_letter(ch) == true) |
| return true; |
| if (is_digit(ch) == true) |
| return true; |
| if (is_combining_char(ch) == true) |
| return true; |
| if (is_extender(ch) == true) |
| return true; |
| if (ch == (uint32_t) '.' || ch == (uint32_t) '-' || |
| ch == (uint32_t) '_' || ch == (uint32_t) ':') |
| return true; |
| return false; |
| } |
| /** |
| * Test whether the name is a valid one according XML 1.0 standard. |
| * For the standard please refer: |
| * |
| * http://www.w3.org/TR/2004/REC-xml-20040204/ |
| * |
| * \param name The name need to be tested |
| * \return true if ::name is valid, false otherwise. |
| */ |
| bool _dom_validate_name(dom_string *name) |
| { |
| uint32_t ch; |
| size_t clen, slen; |
| parserutils_error err; |
| const uint8_t *s; |
| if (name == NULL) |
| return false; |
| slen = dom_string_length(name); |
| if (slen == 0) |
| return false; |
| s = (const uint8_t *) dom_string_data(name); |
| slen = dom_string_byte_length(name); |
| err = parserutils_charset_utf8_to_ucs4(s, slen, &ch, &clen); |
| if (err != PARSERUTILS_OK) { |
| return false; |
| } |
| if (is_first_char(ch) == false) |
| return false; |
| s += clen; |
| slen -= clen; |
| while (slen > 0) { |
| err = parserutils_charset_utf8_to_ucs4(s, slen, &ch, &clen); |
| if (err != PARSERUTILS_OK) { |
| return false; |
| } |
| if (is_name_char(ch) == false) |
| return false; |
| s += clen; |
| slen -= clen; |
| } |
| return true; |
| } |
| /** |
| * Validate whether the string is a legal NCName. |
| * Refer http://www.w3.org/TR/REC-xml-names/ for detail. |
| * |
| * \param str The name to validate |
| * \return true if ::name is valid, false otherwise. |
| */ |
| bool _dom_validate_ncname(dom_string *name) |
| { |
| uint32_t ch; |
| size_t clen, slen; |
| parserutils_error err; |
| const uint8_t *s; |
| if (name == NULL) |
| return false; |
| slen = dom_string_length(name); |
| if (slen == 0) |
| return false; |
| s = (const uint8_t *) dom_string_data(name); |
| slen = dom_string_byte_length(name); |
| err = parserutils_charset_utf8_to_ucs4(s, slen, &ch, &clen); |
| if (err != PARSERUTILS_OK) { |
| return false; |
| } |
| if (is_letter(ch) == false && ch != (uint32_t) '_') |
| return false; |
| s += clen; |
| slen -= clen; |
| while (slen > 0) { |
| err = parserutils_charset_utf8_to_ucs4(s, slen, &ch, &clen); |
| if (err != PARSERUTILS_OK) { |
| return false; |
| } |
| if (is_name_char(ch) == false) |
| return false; |
| if (ch == (uint32_t) ':') |
| return false; |
| s += clen; |
| slen -= clen; |
| } |
| return true; |
| } |
| /contrib/network/netsurf/libdom/src/utils/validate.h |
|---|
| 0,0 → 1,25 |
| /* |
| * This file is part of libdom. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| * |
| * This file contains the API used to validate whether certain element's |
| * name/namespace are legal according the XML 1.0 standard. See |
| * |
| * http://www.w3.org/TR/2004/REC-xml-20040204/ |
| * |
| * for detail. |
| */ |
| #ifndef dom_utils_valid_h_ |
| #define dom_utils_valid_h_ |
| #include <stdbool.h> |
| #include <dom/core/string.h> |
| bool _dom_validate_name(dom_string *name); |
| bool _dom_validate_ncname(dom_string *name); |
| #endif |
| /contrib/network/netsurf/libdom/test/DOMTSHandler.pm |
|---|
| 0,0 → 1,1582 |
| # This is the PerSAX Handlers Package |
| package DOMTSHandler; |
| use Switch; |
| use XML::XPath; |
| use XML::XPath::XMLParser; |
| our $description = 0; |
| our $string_index = 0; |
| our $ret_index = 0; |
| our $condition_index = 0; |
| our $test_index = 0; |
| our $iterator_index = 0; |
| our $temp_index = 0; |
| # Sometimes, we need temp nodes |
| our $tnode_index = 0; |
| our $dom_feature = "\"XML\""; |
| our %bootstrap_api = ( |
| dom_implementation_create_document_type => "", |
| dom_implementation_create_document => "", |
| ); |
| our %native_interface = ( |
| DOMString => \&generate_domstring_interface, |
| DOMTimeStamp => "", |
| DOMUserData => "", |
| DOMObject =>"", |
| ); |
| our %special_type = ( |
| # Some of the type are not defined now! |
| boolean => "bool ", |
| int => "int32_t ", |
| "unsigned long" => "uint32_t ", |
| DOMString => "dom_string *", |
| List => "list *", |
| Collection => "list *", |
| DOMImplementation => "dom_implementation *", |
| NamedNodeMap => "dom_namednodemap *", |
| NodeList => "dom_nodelist *", |
| HTMLCollection => "dom_html_collection *", |
| HTMLFormElement => "dom_html_form_element *", |
| CharacterData => "dom_characterdata *", |
| CDATASection => "dom_cdata_section *", |
| ); |
| our %special_prefix = ( |
| DOMString => "dom_string", |
| DOMImplementation => "dom_implementation", |
| NamedNodeMap => "dom_namednodemap", |
| NodeList => "dom_nodelist", |
| HTMLCollection => "dom_html_collection", |
| HTMLFormElement => "dom_html_form_element", |
| CharacterData => "dom_characterdata", |
| CDATASection => "dom_cdata_section *", |
| ); |
| our %unref_prefix = ( |
| DOMString => "dom_string", |
| NamedNodeMap => "dom_namednodemap", |
| NodeList => "dom_nodelist", |
| HTMLCollection => "dom_html_collection", |
| ); |
| our %special_method = ( |
| ); |
| our %special_attribute = ( |
| namespaceURI => "namespace", |
| ); |
| our %no_unref = ( |
| "boolean" => 1, |
| "int" => 1, |
| "unsigned int" => 1, |
| "List" => 1, |
| "Collection" => 1, |
| ); |
| our %override_suffix = ( |
| boolean => "bool", |
| int => "int", |
| "unsigned long" => "unsigned_long", |
| DOMString => "domstring", |
| DOMImplementation => "domimplementation", |
| NamedNodeMap => "domnamednodemap", |
| NodeList => "domnodelist", |
| HTMLCollection => "domhtmlcollection", |
| Collection => "list", |
| List => "list", |
| ); |
| our %exceptions = ( |
| DOM_NO_ERR => 0, |
| DOM_INDEX_SIZE_ERR => 1, |
| DOM_DOMSTRING_SIZE_ERR => 2, |
| DOM_HIERARCHY_REQUEST_ERR => 3, |
| DOM_WRONG_DOCUMENT_ERR => 4, |
| DOM_INVALID_CHARACTER_ERR => 5, |
| DOM_NO_DATA_ALLOWED_ERR => 6, |
| DOM_NO_MODIFICATION_ALLOWED_ERR => 7, |
| DOM_NOT_FOUND_ERR => 8, |
| DOM_NOT_SUPPORTED_ERR => 9, |
| DOM_INUSE_ATTRIBUTE_ERR => 10, |
| DOM_INVALID_STATE_ERR => 11, |
| DOM_SYNTAX_ERR => 12, |
| DOM_INVALID_MODIFICATION_ERR => 13, |
| DOM_NAMESPACE_ERR => 14, |
| DOM_INVALID_ACCESS_ERR => 15, |
| DOM_VALIDATION_ERR => 16, |
| DOM_TYPE_MISMATCH_ERR => 17, |
| DOM_UNSPECIFIED_EVENT_TYPE_ERR => (1<<30)+0, |
| DOM_DISPATCH_REQUEST_ERR => (1<<30)+1, |
| DOM_NO_MEM_ERR => (1<<31)+0, |
| ); |
| our @condition = qw(same equals notEquals less lessOrEquals greater greaterOrEquals isNull notNull and or xor not instanceOf isTrue isFalse hasSize contentType hasFeature implementationAttribute); |
| our @exception = qw(INDEX_SIZE_ERR DOMSTRING_SIZE_ERR HIERARCHY_REQUEST_ERR WRONG_DOCUMENT_ERR INVALID_CHARACTER_ERR NO_DATA_ALLOWED_ERR NO_MODIFICATION_ALLOWED_ERR NOT_FOUND_ERR NOT_SUPPORTED_ERR INUSE_ATTRIBUTE_ERR NAMESPACE_ERR UNSPECIFIED_EVENT_TYPE_ERR DISPATCH_REQUEST_ERR); |
| our @assertion = qw(assertTrue assertFalse assertNull assertNotNull assertEquals assertNotEquals assertSame assertInstanceOf assertSize assertEventCount assertURIEquals); |
| our @assertexception = qw(assertDOMException assertEventException assertImplementationException); |
| our @control = qw(if while for-each else); |
| our @framework_statement = qw(assign increment decrement append plus subtract mult divide load implementation comment hasFeature implementationAttribute EventMonitor.setUserObj EventMonitor.getAtEvents EventMonitor.getCaptureEvents EventMonitor.getBubbleEvents EventMonitor.getAllEvents wait); |
| sub new { |
| my $type = shift; |
| my $dtd = shift; |
| my $chdir = shift; |
| my $dd = XML::XPath->new(filename => $dtd); |
| my $self = { |
| # The DTD file of the xml files |
| dd => $dd, |
| # To indicate whether we are in comments |
| comment => 0, |
| # To indicate that whether we are in <comment> element |
| inline_comment => 0, |
| # The stack of elements encountered utill now |
| context => [], |
| # The map for <var> name => type |
| var => {}, |
| # See the comment on generate_condition2 for this member |
| condition_stack => [], |
| # The list for UNREF |
| unref => [], |
| string_unref => [], |
| # The indent of current statement |
| indent => "", |
| # The variables for List/Collection |
| # We now, declare an array for a list and then add them into a list |
| # The map for all the List/Collection in one test |
| # "List Name" => "Member type" |
| list_map => {}, |
| # The name of the current List/Collection |
| list_name => "", |
| # The number of items of the current List/Collection |
| list_num => 0, |
| # Whether List/Collection has members |
| list_hasmem => 0, |
| # The type of the current List/Collection |
| list_type => "", |
| # Whether we are in exception assertion |
| exception => 0, |
| # Where to chdir |
| chdir => $chdir |
| }; |
| return bless $self, $type; |
| } |
| sub start_element { |
| my ($self, $element) = @_; |
| my $en = $element->{Name}; |
| my $dd = $self->{dd}; |
| my $ct = $self->{context}; |
| push(@$ct, $en); |
| switch ($en) { |
| case "test" { |
| ; |
| } |
| case "metadata" { |
| # start comments here |
| print "/*\n"; |
| $self->{comment} = 1; |
| } |
| # Print the var definition |
| case "var" { |
| $self->generate_var($element->{Attributes}); |
| } |
| case "member" { |
| if ($self->{context}->[-2] eq "var") { |
| if ($self->{"list_hasmem"} eq 1) { |
| print ", "; |
| } |
| $self->{"list_hasmem"} = 1; |
| $self->{"list_num"} ++; |
| } |
| } |
| # The framework statements |
| case [@framework_statement] { |
| # Because the implementationAttribute & hasFeature belongs to both |
| # framework-statement and condition, we should distinct the two |
| # situation here. Let the generate_condtion to do the work. |
| if ($en eq "hasFeature" || $en eq "implementationAttribute") { |
| next; |
| } |
| $self->generate_framework_statement($en, $element->{Attributes}); |
| } |
| case [@control] { |
| $self->generate_control_statement($en, $element->{Attributes}); |
| } |
| # Test condition |
| case [@condition] { |
| $self->generate_condition($en, $element->{Attributes}); |
| } |
| # The assertsions |
| case [@assertion] { |
| $self->generate_assertion($en, $element->{Attributes}); |
| } |
| case [@assertexception] { |
| # Indeed, nothing to do here! |
| } |
| # Deal with exception |
| case [@exception] { |
| # Just see end_element |
| $self->{'exception'} = 1; |
| } |
| # Then catch other case |
| else { |
| # we don't care the comment nodes |
| if ($self->{comment} eq 0) { |
| $self->generate_interface($en, $element->{Attributes}); |
| } |
| } |
| } |
| } |
| sub end_element { |
| my ($self, $element) = @_; |
| my @ct = @{$self->{context}}; |
| my $name = pop(@{$self->{context}}); |
| switch ($name) { |
| case "metadata" { |
| print "*/\n"; |
| $self->{comment} = 0; |
| $self->generate_main(); |
| } |
| case "test" { |
| $self->cleanup(); |
| } |
| case "var" { |
| $self->generate_list(); |
| } |
| # End of condition |
| case [@condition] { |
| $self->complete_condition($name); |
| } |
| # The assertion |
| case [@assertion] { |
| $self->complete_assertion($name); |
| } |
| case [@control] { |
| $self->complete_control_statement($name); |
| } |
| case [@exception] { |
| $name = "DOM_".$name; |
| print "assert(exp == $exceptions{$name});\n"; |
| $self->{'exception'} = 0; |
| } |
| } |
| } |
| sub characters { |
| my ($self, $data) = @_; |
| our $description; |
| my $ct = $self->{context}; |
| if ($self->{"inline_comment"} eq 1) { |
| print "$data->{Data}"; |
| return ; |
| } |
| # We print the comments here |
| if ($self->{comment} eq 1) { |
| # So, we are in comments state |
| my $top = $ct->[$#{$ct}]; |
| if ($top eq "metadata") { |
| return; |
| } |
| if ($top eq "description") { |
| if ($description eq 0) { |
| print "description: \n"; |
| $description = 1; |
| } |
| print "$data->{Data}"; |
| } else { |
| print "$top: $data->{Data}\n"; |
| } |
| return; |
| } |
| if ($self->{context}->[-1] eq "member") { |
| # We should mark that the List/Collection has members |
| $self->{"list_hasmem"} = 1; |
| # Here, we should detect the characters type |
| # whether it is a integer or string (now, we only take care |
| # of the two types, because I did not find any other type). |
| if ($self->{"list_type"} eq "") { |
| if ($data->{Data} =~ /^\"/) { |
| $self->{"list_type"} = "char *"; |
| print "const char *".$self->{"list_name"}."Array[] = \{ $data->{Data}"; |
| } else { |
| if ($data->{Data} =~ /^[0-9]+/) { |
| $self->{"list_type"} = "int *"; |
| print "int ".$self->{"list_name"}."Array[] = \{ $data->{Data}"; |
| } else { |
| die "Some data in the <member> we can't process: \"$data->{Data}\""; |
| } |
| } |
| } else { |
| # So, we must have known the type, just output the member |
| print "$data->{Data}"; |
| } |
| } |
| } |
| sub generate_main { |
| my $self = shift; |
| # Firstly, push a new "b" to the string_unref list |
| push(@{$self->{"string_unref"}}, "b"); |
| print << "__EOF__" |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdbool.h> |
| #include <unistd.h> |
| #include <dom/dom.h> |
| #include <dom/functypes.h> |
| #include <domts.h> |
| dom_implementation *doc_impl; |
| int main(int argc, char **argv) |
| { |
| dom_exception exp; |
| (void)argc; |
| (void)argv; |
| if (chdir("$self->{chdir}") < 0) { |
| perror("chdir (\\"$self->{chdir})\\""); |
| return 1; |
| } |
| __EOF__ |
| } |
| # Note that, we have not just declare variables here |
| # we should also define EventListener here! |
| # I think this should be done after the EventListener design |
| # is complete |
| sub generate_var { |
| my ($self, $ats) = @_; |
| my $type = ""; |
| my $dstring = ""; |
| # For the case like <var name="v" type="DOMString" value="some some" |
| if ($ats->{"type"} eq "DOMString" and exists $ats->{"value"}) { |
| $dstring = $self->generate_domstring($ats->{"value"}); |
| $ats->{"value"} = $dstring; |
| } |
| $type = type_to_ctype($ats->{"type"}); |
| if ($type eq "") { |
| print "Not implement this type now\n"; |
| return; |
| } |
| print "\t$type$ats->{'name'}"; |
| if (exists $ats->{"value"}) { |
| print " = $ats->{'value'};\n"; |
| } else { |
| if ($type =~ m/\*/) { |
| print " = NULL;\n"; |
| } else { |
| print ";\n"; |
| } |
| } |
| my $var = $self->{"var"}; |
| $var->{$ats->{"name"}} = $ats->{"type"}; |
| # If the type is List/Collection, we should take care of it |
| if ($ats->{"type"} =~ /^(List|Collection)$/) { |
| $self->{"list_name"} = $ats->{"name"}; |
| } |
| } |
| sub generate_list { |
| my $self = shift; |
| # We should deal with the end of <var> when the <var> is declaring a List/Collection |
| if ($self->{"list_hasmem"} eq 1) { |
| # Yes, we are in List/Collection declaration |
| # Firstly, enclose the Array declaration |
| print "};\n"; |
| # Now, we should create the list * for the List/Collection |
| # Note, we should deal with "int" or "string" type with different params. |
| if ($self->{"list_type"} eq "char *") { |
| print $self->{"list_name"}." = list_new(STRING);\n"; |
| } |
| if ($self->{"list_type"} eq "int *") { |
| print $self->{"list_name"}." = list_new(INT);\n"; |
| } |
| if ($self->{"list_type"} eq "") { |
| die "A List/Collection has children member but no type is impossible!"; |
| } |
| for (my $i = 0; $i < $self->{"list_num"}; $i++) { |
| # Use *(char **) to convert char *[] to char * |
| print "list_add(".$self->{"list_name"}.", *(char **)(".$self->{"list_name"}."Array + $i));\n"; |
| } |
| } else { |
| if ($self->{"list_name"} ne "") { |
| #TODO: generally, we set the list type as dom_string, but it may be dom_node |
| print $self->{"list_name"}." = list_new(DOM_STRING);\n"; |
| $self->{"list_type"} = "DOMString"; |
| } |
| } |
| # Add the List/Collection to map |
| $self->{"list_map"}->{$self->{"list_name"}} = $self->{"list_type"}; |
| # Reset the List/Collection member state |
| $self->{"list_hasmem"} = 0; |
| $self->{"list_name"} = ""; |
| $self->{"list_type"} = ""; |
| $self->{"list_num"} = 0; |
| } |
| sub generate_load { |
| my ($self, $a) = @_; |
| my %ats = %$a; |
| my $doc = $ats{"var"}; |
| $test_index ++; |
| # define the test file path, use HTML if there is, otherwise using XML |
| # Attention: I intend to copy the test files to the program excuting dir |
| print "\tconst char *test$test_index = \"$ats{'href'}.html\";\n\n"; |
| print "\t$doc = load_html(test$test_index, $ats{'willBeModified'});"; |
| print "\tif ($doc == NULL) {\n"; |
| $test_index ++; |
| print "\t\tconst char *test$test_index = \"$ats{'href'}.xml\";\n\n"; |
| print "\t\t$doc = load_xml(test$test_index, $ats{'willBeModified'});\n"; |
| print "\t\tif ($doc == NULL)\n"; |
| print "\t\t\treturn 1;\n"; |
| print "\t\t}\n"; |
| print << "__EOF__"; |
| exp = dom_document_get_implementation($doc, &doc_impl); |
| if (exp != DOM_NO_ERR) |
| return exp; |
| __EOF__ |
| $self->addto_cleanup($doc); |
| } |
| sub generate_framework_statement { |
| my ($self, $name, $ats) = @_; |
| switch($name) { |
| case "load" { |
| $self->generate_load($ats); |
| } |
| case "assign" { |
| my $var = $ats->{"var"}; |
| my $value = "0"; |
| if (exists $ats->{"value"}) { |
| $value = $ats->{"value"}; |
| } |
| # Assign with strong-type-conversion, this is necessary in C. |
| # And we may need to do deep-copy in the future. FIXME |
| my $type = type_to_ctype($self->{"var"}->{$var}); |
| print "$var = \($type\) $value;\n"; |
| } |
| case "increment" { |
| my $var = $ats->{"var"}; |
| my $value = $ats->{"value"}; |
| print "$var += $value;\n"; |
| } |
| case "decrement" { |
| my $var = $ats->{"var"}; |
| my $value = $ats->{"value"}; |
| print "$var -= $value;\n"; |
| } |
| case "append" { |
| my $col = $ats->{"collection"}; |
| my $obj = ""; |
| # God, the DTD said, there should be a "OBJ" attribute, but there may not! |
| if (exists $ats->{"obj"}) { |
| $obj = $ats->{"obj"}; |
| } else { |
| $obj = $ats->{"item"} |
| } |
| if (not $self->{"var"}->{$col} =~ /^(List|Collection)/) { |
| die "Append data to some non-list type!"; |
| } |
| print "list_add($col, $obj);\n"; |
| } |
| case [qw(plus subtract mult divide)] { |
| my $var = $ats->{"var"}; |
| my $op1 = $ats->{"op1"}; |
| my $op2 = $ats->{"op2"}; |
| my %table = ("plus", "+", "subtract", "-", "mult", "*", "divide", "/"); |
| print "$var = $op1 $table{$name} $op2;\n"; |
| } |
| case "comment" { |
| print "\*"; |
| $self->{"inline_comment"} = 1; |
| } |
| case "implementation" { |
| if (not exists $ats->{"obj"}) { |
| my $var = $ats->{"var"}; |
| my $dstring = generate_domstring($self, $dom_feature); |
| print "exp = dom_implregistry_get_dom_implementation($dstring, \&$var);\n"; |
| print "\tif (exp != DOM_NO_ERR) {\n"; |
| $self->cleanup_fail("\t\t"); |
| print "\t\treturn exp;\n\t}\n"; |
| last; |
| } |
| my $obj = $ats->{"obj"}; |
| my $var = $ats->{"var"}; |
| # Here we directly output the libDOM's get_implementation API |
| print "\texp = dom_document_get_implementation($obj, \&$var);\n"; |
| print "\tif (exp != DOM_NO_ERR) {\n"; |
| $self->cleanup_fail("\t\t"); |
| print "\t\treturn exp;\n\t}\n"; |
| } |
| # We deal with hasFeaturn and implementationAttribute in the generate_condition |
| case "hasFeature" { |
| die "No, never can be here!"; |
| } |
| case "implementaionAttribute" { |
| die "No, never can be here!"; |
| } |
| # Here, we die because we did not implement other statements |
| # We did not implement these statements, because there are no use of them in the W3C DOMTS now |
| case [@framework_statement] { |
| die "The statement \"$name\" is not implemented yet!"; |
| } |
| } |
| } |
| sub complete_framework_statement { |
| my ($self, $name) = @_; |
| switch($name) { |
| case "comment" { |
| print "*/\n"; |
| $self->{"inline_comment"} = 0; |
| } |
| } |
| } |
| sub generate_interface { |
| my ($self, $en, $a) = @_; |
| my %ats = %$a; |
| my $dd = $self->{dd}; |
| if (exists $ats{'interface'}) { |
| # Firstly, test whether it is a DOM native interface |
| if (exists $native_interface{$ats{'interface'}}) { |
| if ($native_interface{$ats{'interface'}} eq "") { |
| die "Unkown how to deal with $en of $ats{'interface'}"; |
| } |
| return $native_interface{$ats{'interface'}}($self, $en, $a); |
| } |
| my $ns = $dd->find("/library/interface[\@name=\"$ats{'interface'}\"]/method[\@name=\"$en\"]"); |
| if ($ns->size() != 0) { |
| my $node = $ns->get_node(1); |
| $self->generate_method($en, $node, %ats); |
| } else { |
| my $ns = $dd->find("/library/interface[\@name=\"$ats{'interface'}\"]/attribute[\@name=\"$en\"]"); |
| if ($ns->size() != 0) { |
| my $node = $ns->get_node(1); |
| $self->generate_attribute_accessor($en, $node, %ats); |
| } |
| } |
| } else { |
| my $ns = $dd->find("/library/interface/method[\@name=\"$en\"]"); |
| if ($ns->size() != 0) { |
| my $node = $ns->get_node(1); |
| $self->generate_method($en, $node, %ats); |
| } else { |
| my $ns = $dd->find("/library/interface/attribute[\@name=\"$en\"]"); |
| if ($ns->size() != 0) { |
| my $node = $ns->get_node(1); |
| $self->generate_attribute_accessor($en, $node, %ats); |
| } else { |
| die "Oh, Can't find how to deal with the element $en\n"; |
| } |
| } |
| } |
| } |
| sub generate_method { |
| my ($self, $en, $node, %ats) = @_; |
| my $dd = $self->{dd}; |
| if (! exists $ats{'interface'}) { |
| my $n = $node; |
| while($n->getLocalName() ne "interface") { |
| $n = $n->getParentNode(); |
| } |
| $ats{'interface'} = $n->getAttribute("name"); |
| } |
| $method = to_cmethod($ats{'interface'}, $en); |
| my $cast = to_attribute_cast($ats{'interface'}); |
| my $ns = $dd->find("parameters/param", $node); |
| my $params = "${cast}$ats{'obj'}"; |
| for ($count = 1; $count <= $ns->size; $count++) { |
| my $n = $ns->get_node($count); |
| my $p = $n->getAttribute("name"); |
| my $t = $n->getAttribute("type"); |
| # Change the raw string and the char * to dom_string |
| if ($t eq "DOMString") { |
| if ($ats{$p} =~ /^"/ or $self->{"var"}->{$ats{$p}} eq "char *") { |
| $self->generate_domstring($ats{$p}); |
| $params = $params.", dstring$string_index"; |
| next; |
| } |
| } |
| # For the case that the testcase did not provide the param, we just pass a NULL |
| # Because we are in C, not like C++ which can overriden functions |
| if (not exists $ats{$p}) { |
| $params = $params.", NULL"; |
| next; |
| } |
| $params = $params.", $ats{$p}"; |
| } |
| #$ns = $dd->find("returns", $node); |
| #my $n = $ns->get_node(1); |
| #my $t = $n->getAttribute("type"); |
| # declare the return value |
| #my $tp = type_to_ctype($t); |
| #print "\t$tp ret$ret_index;\n"; |
| my $unref = 0; |
| my $temp_node = 0; |
| if (exists $ats{'var'}) { |
| # Add the bootstrap params |
| if (exists $bootstrap_api{$method}) { |
| if ($method eq "dom_implementation_create_document") { |
| $params = $params.", myrealloc, NULL, NULL"; |
| } else { |
| $params = $params.", myrealloc, NULL"; |
| } |
| } |
| # Deal with the situation like |
| # |
| # dom_node_append_child(node, new_node, &node); |
| # |
| # Here, we should import a tempNode, and change this expression to |
| # |
| # dom_node *tnode1 = NULL; |
| # dom_node_append_child(node, new_node, &tnode1); |
| # dom_node_unref(node); |
| # node = tnode1; |
| # |
| # Over. |
| if ($ats{'obj'} eq $ats{'var'}) { |
| my $t = type_to_ctype($self->{'var'}->{$ats{'var'}}); |
| $tnode_index ++; |
| print "$t tnode$tnode_index = NULL;"; |
| $params = $params.", \&tnode$tnode_index"; |
| # The ats{'obj'} must have been added to cleanup stack |
| $unref = 1; |
| # Indicate that we have created a temp node |
| $temp_node = 1; |
| } else { |
| $params = $params.", (void *) \&$ats{'var'}"; |
| $unref = $self->param_unref($ats{'var'}); |
| } |
| } |
| print "\texp = $method($params);\n"; |
| if ($self->{'exception'} eq 0) { |
| print << "__EOF__"; |
| if (exp != DOM_NO_ERR) { |
| fprintf(stderr, "Exception raised from %s\\n", "$method"); |
| __EOF__ |
| $self->cleanup_fail("\t\t"); |
| print << "__EOF__"; |
| return exp; |
| } |
| __EOF__ |
| } |
| if (exists $ats{'var'} and $unref eq 0) { |
| $self->addto_cleanup($ats{'var'}); |
| } |
| if ($temp_node eq 1) { |
| my $t = $self->{'var'}->{$ats{'var'}}; |
| if (not exists $no_unref{$t}) { |
| my $prefix = "dom_node"; |
| if (exists $unref_prefix{$t}) { |
| $prefix = $unref_prefix{$t}; |
| } |
| print $prefix."_unref(".$ats{'obj'}.");\n"; |
| } |
| print "$ats{'var'} = tnode$tnode_index;"; |
| } |
| } |
| sub generate_attribute_accessor { |
| my ($self, $en, $node, %ats) = @_; |
| if (defined($ats{'var'})) { |
| generate_attribute_fetcher(@_); |
| } else { |
| if (defined($ats{'value'})) { |
| generate_attribute_setter(@_); |
| } |
| } |
| } |
| sub generate_attribute_fetcher { |
| my ($self, $en, $node, %ats) = @_; |
| my $dd = $self->{dd}; |
| if (! exists $ats{'interface'}) { |
| my $n = $node; |
| while($n->getLocalName() ne "interface") { |
| $n = $n->getParentNode(); |
| } |
| $ats{'interface'} = $n->getAttribute("name"); |
| } |
| my $fetcher = to_attribute_fetcher($ats{'interface'}, "$en"); |
| my $cast = to_attribute_cast($ats{'interface'}); |
| my $unref = 0; |
| my $temp_node = 0; |
| # Deal with the situation like |
| # |
| # dom_node_get_next_sibling(child, &child); |
| # |
| # Here, we should import a tempNode, and change this expression to |
| # |
| # dom_node *tnode1 = NULL; |
| # dom_node_get_next_sibling(child, &tnode1); |
| # dom_node_unref(child); |
| # child = tnode1; |
| # |
| # Over. |
| if ($ats{'obj'} eq $ats{'var'}) { |
| my $t = type_to_ctype($self->{'var'}->{$ats{'var'}}); |
| $tnode_index ++; |
| print "\t$t tnode$tnode_index = NULL;\n"; |
| print "\texp = $fetcher(${cast}$ats{'obj'}, \&tnode$tnode_index);\n"; |
| # The ats{'obj'} must have been added to cleanup stack |
| $unref = 1; |
| # Indicate that we have created a temp node |
| $temp_node = 1; |
| } else { |
| $unref = $self->param_unref($ats{'var'}); |
| print "\texp = $fetcher(${cast}$ats{'obj'}, \&$ats{'var'});\n"; |
| } |
| if ($self->{'exception'} eq 0) { |
| print << "__EOF__"; |
| if (exp != DOM_NO_ERR) { |
| fprintf(stderr, "Exception raised when fetch attribute %s", "$en"); |
| __EOF__ |
| $self->cleanup_fail("\t\t"); |
| print << "__EOF__"; |
| return exp; |
| } |
| __EOF__ |
| } |
| if ($temp_node eq 1) { |
| my $t = $self->{'var'}->{$ats{'var'}}; |
| if (not exists $no_unref{$t}) { |
| my $prefix = "dom_node"; |
| if (exists $unref_prefix{$t}) { |
| $prefix = $unref_prefix{$t}; |
| } |
| print $prefix."_unref(".$ats{'obj'}.");\n"; |
| } |
| print "$ats{'var'} = tnode$tnode_index;"; |
| } |
| if ($unref eq 0) { |
| $self->addto_cleanup($ats{'var'}); |
| } |
| } |
| sub generate_attribute_setter { |
| my ($self, $en, $node, %ats) = @_; |
| my $dd = $self->{dd}; |
| if (! exists $ats{'interface'}) { |
| my $n = $node; |
| while($n->getLocalName() ne "interface") { |
| $n = $n->getParentNode(); |
| } |
| $ats{'interface'} = $n->getAttribute("name"); |
| } |
| my $setter = to_attribute_setter($ats{'interface'}, "$en"); |
| my $param = "$ats{'obj'}"; |
| # For DOMString, we should deal specially |
| my $lp = $ats{'value'}; |
| if ($node->getAttribute("type") eq "DOMString") { |
| if ($ats{'value'} =~ /^"/ or $self->{"var"}->{$ats{'value'}} eq "char *") { |
| $lp = $self->generate_domstring($ats{'value'}); |
| } |
| } |
| $param = $param.", $lp"; |
| print "exp = $setter($param);"; |
| if ($self->{'exception'} eq 0) { |
| print << "__EOF__"; |
| if (exp != DOM_NO_ERR) { |
| fprintf(stderr, "Exception raised when fetch attribute %s", "$en"); |
| __EOF__ |
| $self->cleanup_fail("\t\t"); |
| print << "__EOF__"; |
| return exp; |
| } |
| __EOF__ |
| } |
| } |
| sub generate_condition { |
| my ($self, $name, $ats) = @_; |
| # If we are in nested or/and/xor/not, we should put a operator before test |
| my @array = @{$self->{condition_stack}}; |
| if ($#array ge 0) { |
| switch ($array[-1]) { |
| case "xor" { |
| print " ^ "; |
| } |
| case "or" { |
| print " || "; |
| } |
| case "and" { |
| print " && "; |
| } |
| # It is the indicator, just pop it. |
| case "new" { |
| pop(@{$self->{condition_stack}}); |
| } |
| } |
| } |
| switch ($name) { |
| case [qw(less lessOrEquals greater greaterOrEquals)] { |
| my $actual = $ats->{actual}; |
| my $expected = $ats->{expected}; |
| my $method = $name; |
| $method =~ s/[A-Z]/_$&/g; |
| $method = lc $method; |
| print "$method($expected, $actual)"; |
| } |
| case "same" { |
| my $actual = $ats->{actual}; |
| my $expected = $ats->{expected}; |
| my $func = $self->find_override("is_same", $actual, $expected); |
| print "$func($expected, $actual)"; |
| } |
| case [qw(equals notEquals)]{ |
| my $actual = $ats->{actual}; |
| my $expected = $ats->{expected}; |
| my $ig; |
| if (exists $ats->{ignoreCase}){ |
| $ig = $ats->{ignoreCase}; |
| } else { |
| $ig = "false"; |
| } |
| $ig = adjust_ignore($ig); |
| my $func = $self->find_override("is_equals", $actual, $expected); |
| if ($name =~ /not/i){ |
| print "(false == $func($expected, $actual, $ig))"; |
| } else { |
| print "$func($expected, $actual, $ig)"; |
| } |
| } |
| case [qw(isNull notNull)]{ |
| my $obj = $ats->{obj}; |
| if ($name =~ /not/i) { |
| print "(false == is_null($obj))"; |
| } else { |
| print "is_null($obj)"; |
| } |
| } |
| case "isTrue" { |
| my $value = $ats->{value}; |
| print "is_true($value)"; |
| } |
| case "isFalse" { |
| my $value = $ats->{value}; |
| print "(false == is_true($value))"; |
| } |
| case "hasSize" { |
| my $obj = $ats->{obj}; |
| my $size = $ats->{expected}; |
| my $func = $self->find_override("is_size", $obj, $size); |
| print "$func($size, $obj)"; |
| } |
| case "contentType" { |
| my $type = $ats->{type}; |
| print "is_contenttype(\"$type\")"; |
| } |
| case "instanceOf" { |
| my $obj = $ats->{obj}; |
| my $type = $ats->{type}; |
| print "instanceOf(\"$type\", $obj)"; |
| } |
| case "hasFeature" { |
| if (exists $ats->{var}) { |
| $self->generate_interface($name, $ats); |
| } else { |
| my $feature = $ats->{feature}; |
| if (not ($feature =~ /^"/)) { |
| $feature = '"'.$feature.'"'; |
| } |
| my $version = "NULL"; |
| if (exists $ats->{version}) { |
| $version = $ats->{version}; |
| if (not ($version =~ /^"/)) { |
| $version = '"'.$version.'"'; |
| } |
| } |
| if ($self->{context}->[-2] ne "condition") { |
| # we are not in a %condition place, so we must be a statement |
| # we change this to assert |
| # print "assert(has_feature($feature, $version));\n" |
| # do nothing if we are not in condition. |
| } else { |
| print "has_feature($feature, $version)"; |
| } |
| } |
| } |
| case "implementationAttribute" { |
| my $value = $ats->{value}; |
| my $name = $ats->{name}; |
| if ($self->{context}->[-2] ne "condition") { |
| # print "assert(implementation_attribute(\"$name\", $value));"; |
| # Do nothing, and the same with hasFeature, this means we will |
| # run all test cases now and try to get a result whether we support |
| # such feature. |
| } else { |
| print "implementation_attribute(\"$name\", $value)"; |
| } |
| } |
| case [qw(and or xor)] { |
| push(@{$self->{condition_stack}}, $name); |
| push(@{$self->{condition_stack}}, "new"); |
| print "("; |
| } |
| case "not" { |
| push(@{$self->{condition_stack}}, $name); |
| print "(false == "; |
| } |
| } |
| } |
| sub complete_condition { |
| my ($self, $name) = @_; |
| if ($name =~ /^(xor|or|and)$/i) { |
| print ")"; |
| my $top = pop(@{$self->{condition_stack}}); |
| die "Condition stack error! $top != $name" if $top ne $name; |
| } |
| if ($name eq "not") { |
| my $top = pop(@{$self->{condition_stack}}); |
| die "Condition stack error! $top != $name" if $top ne $name; |
| print ")"; |
| } |
| # we deal with the situation that the %condition is in a control statement such as |
| # <if> or <while>, and we should start a new '{' block here |
| if ($self->{context}->[-1] eq "condition") { |
| print ") {\n"; |
| pop(@{$self->{context}}); |
| } |
| } |
| sub generate_assertion { |
| my ($self, $name, $ats) = @_; |
| print "\tassert("; |
| switch($name){ |
| # Only assertTrue & assertFalse can have nested %conditions |
| case [qw(assertTrue assertFalse assertNull)] { |
| my $n = $name; |
| $n =~ s/assert/is/g; |
| if (exists $ats->{actual}){ |
| my $ta = { value => $ats->{actual}, obj => $ats->{actual}}; |
| $self->generate_condition($n,$ta); |
| } |
| } |
| case [qw(assertNotNull assertEquals assertNotEquals assertSame)] { |
| my $n = $name; |
| $n =~ s/assert//g; |
| $n = lcfirst $n; |
| if (exists $ats->{actual}){ |
| my $ta = { |
| actual => $ats->{actual}, |
| value => $ats->{actual}, |
| obj => $ats->{actual}, |
| expected => $ats->{expected}, |
| ignoreCase => $ats->{ignoreCase}, |
| type => $ats->{type}, |
| }; |
| $self->generate_condition($n,$ta); |
| } |
| } |
| case "assertInstanceOf" { |
| my $obj = $ats->{obj}; |
| my $type = $ats->{type}; |
| print "is_instanceof(\"$type\", $obj)"; |
| } |
| case "assertSize" { |
| my $n = $name; |
| $n =~ s/assert/has/; |
| if (exists $ats->{collection}){ |
| my $ta = { obj => $ats->{collection}, expected => $ats->{size}}; |
| $self->generate_condition($n,$ta); |
| } |
| } |
| case "assertEventCount" { |
| #todo |
| } |
| case "assertURIEquals" { |
| my $actual = $ats->{actual}; |
| my ($scheme, $path, $host, $file, $name, $query, $fragment, $isAbsolute) = qw(NULL NULL NULL NULL NULL NULL NULL NULL); |
| if (exists $ats->{scheme}) { |
| $scheme = $ats->{scheme}; |
| } |
| if (exists $ats->{path}) { |
| $path = $ats->{path}; |
| } |
| if (exists $ats->{host}) { |
| $host = $ats->{host}; |
| } |
| if (exists $ats->{file}) { |
| $file = $ats->{file}; |
| } |
| if (exists $ats->{name}) { |
| $name = $ats->{name}; |
| } |
| if (exists $ats->{query}) { |
| $query = $ats->{query}; |
| } |
| if (exists $ats->{fragment}) { |
| $fragment = $ats->{fragment}; |
| } |
| if (exists $ats->{isAbsolute}) { |
| $isAbsolute = $ats->{isAbsolute}; |
| } |
| print "is_uri_equals($scheme, $path, $host, $file, $name, $query, $fragment, $isAbsolute, $actual)" |
| } |
| } |
| } |
| sub complete_assertion { |
| my ($self, $name) = @_; |
| print ");\n"; |
| } |
| sub generate_control_statement { |
| my ($self, $name, $ats) = @_; |
| switch($name) { |
| case "if" { |
| print "\tif("; |
| push(@{$self->{"context"}}, "condition"); |
| } |
| case "else" { |
| $self->cleanup_block_domstring(); |
| print "\t} else {"; |
| } |
| case "while" { |
| print "\twhile ("; |
| push(@{$self->{"context"}}, "condition"); |
| } |
| case "for-each" { |
| # Detect what is the collection type, if it is "string", we |
| # should also do some conversion work |
| my $coll = $ats->{"collection"}; |
| # The default member type is dom_node |
| my $type = "dom_node *"; |
| if (exists $self->{"list_map"}->{$coll}) { |
| $type = $self->{"list_map"}->{$coll}; |
| } |
| # Find the member variable, if it is not declared before, declare it firstly |
| my $member = $ats->{"member"}; |
| if (not exists $self->{"var"}->{$member}) { |
| print "$type $member;\n"; |
| # Add the new variable to the {var} map |
| $self->{"var"}->{"$member"} = $type; |
| } |
| # Now the member is conformed to be declared |
| if ($self->{"var"}->{$coll} =~ /^(List|Collection)$/) { |
| # The element in the list is not equal with the member object |
| # For now, there is only one case for this, it is "char *" <=> "DOMString" |
| my $conversion = 0; |
| if ($self->{"var"}->{"$member"} ne $type) { |
| if ($self->{"var"}->{"$member"} eq "DOMString") { |
| if ($type eq "char *") { |
| $conversion = 1; |
| } |
| } |
| } |
| $iterator_index++; |
| print "unsigned int iterator$iterator_index = 0;"; |
| if ($conversion eq 1) { |
| print "char *tstring$temp_index = NULL;"; |
| } |
| print "foreach_initialise_list($coll, \&iterator$iterator_index);\n"; |
| print "while(get_next_list($coll, \&iterator$iterator_index, "; |
| if ($conversion eq 1) { |
| print "\&tstring$temp_index)) {\n"; |
| print "exp = dom_string_create((const uint8_t *)tstring$temp_index,"; |
| print "strlen(tstring$temp_index), &$member);\n"; |
| print "if (exp != DOM_NO_ERR) {\n"; |
| print "\t\tfprintf(stderr, \"Can't create DOMString\\n\");"; |
| $self->cleanup_fail("\t\t"); |
| print "\t\treturn exp;\n\t}\n"; |
| $temp_index ++; |
| } else { |
| print "\&$member)) {\n"; |
| } |
| } |
| if ($self->{"var"}->{$coll} eq "NodeList") { |
| $iterator_index++; |
| print "unsigned int iterator$iterator_index = 0;"; |
| print "foreach_initialise_domnodelist($coll, \&iterator$iterator_index);\n"; |
| print "while(get_next_domnodelist($coll, \&iterator$iterator_index, \&$member)) {\n"; |
| } |
| if ($self->{"var"}->{$coll} eq "NamedNodeMap") { |
| $iterator_index++; |
| print "unsigned int iterator$iterator_index = 0;"; |
| print "foreach_initialise_domnamednodemap($coll, \&iterator$iterator_index);\n"; |
| print "while(get_next_domnamednodemap($coll, \&iterator$iterator_index, \&$member)) {\n"; |
| } |
| if ($self->{"var"}->{$coll} eq "HTMLCollection") { |
| $iterator_index++; |
| print "unsigned int iterator$iterator_index = 0;"; |
| print "foreach_initialise_domhtmlcollection($coll, \&iterator$iterator_index);\n"; |
| print "while(get_next_domhtmlcollection($coll, \&iterator$iterator_index, \&$member)) {\n"; |
| } |
| } |
| } |
| # Firstly, we enter a new block, so push a "b" into the string_unref list |
| push(@{$self->{"string_unref"}}, "b"); |
| } |
| sub complete_control_statement { |
| my ($self, $name) = @_; |
| # Note: we only print a '}' when <if> element ended but not <else> |
| # The reason is that there may be no <else> element in <if> and |
| # we when there is an <else> element, it must nested in <if>. ^_^ |
| switch($name) { |
| case [qw(if while for-each)] { |
| # Firstly, we should cleanup the dom_string in this block |
| $self->cleanup_block_domstring(); |
| print "}\n"; |
| } |
| } |
| } |
| ############################################################################### |
| # |
| # The helper functions |
| # |
| sub generate_domstring { |
| my ($self, $str) = @_; |
| $string_index = $string_index + 1; |
| print << "__EOF__"; |
| const char *string$string_index = $str; |
| dom_string *dstring$string_index; |
| exp = dom_string_create((const uint8_t *)string$string_index, |
| strlen(string$string_index), &dstring$string_index); |
| if (exp != DOM_NO_ERR) { |
| fprintf(stderr, "Can't create DOMString\\n"); |
| __EOF__ |
| $self->cleanup_fail("\t\t"); |
| print << "__EOF__"; |
| return exp; |
| } |
| __EOF__ |
| push(@{$self->{string_unref}}, "$string_index"); |
| return "dstring$string_index"; |
| } |
| sub cleanup_domstring { |
| my ($self, $indent) = @_; |
| for (my $i = 0; $i <= $#{$self->{string_unref}}; $i++) { |
| if ($self->{string_unref}->[$i] ne "b") { |
| print $indent."dom_string_unref(dstring$self->{string_unref}->[$i]);\n"; |
| } |
| } |
| } |
| sub cleanup_block_domstring { |
| my $self = shift; |
| while ((my $num = pop(@{$self->{string_unref}})) ne "b" and $#{$self->{string_unref}} ne -1) { |
| print "dom_string_unref(dstring$num);\n"; |
| } |
| } |
| sub type_to_ctype { |
| my $type = shift; |
| if (exists $special_type{$type}) { |
| return $special_type{$type}; |
| } |
| # If the type is not specially treated, we can transform it by rules |
| if ($type =~ m/^HTML/) { |
| # Don't deal with this now |
| return ""; |
| } |
| # The core module comes here |
| $type =~ s/[A-Z]/_$&/g; |
| $type = lc $type; |
| # For events module |
| $type =~ s/_u_i_/_ui_/g; |
| return "dom".$type." *"; |
| } |
| sub to_cmethod { |
| my ($type, $m) = @_; |
| my $prefix = get_prefix($type); |
| my $ret; |
| if (exists $special_method{$m}) { |
| $ret = $prefix."_".$special_method{$m}; |
| } else { |
| $m =~ s/[A-Z]/_$&/g; |
| $m = lc $m; |
| $ret = $prefix."_".$m; |
| } |
| $ret =~ s/h_t_m_l/html/; |
| $ret =~ s/c_d_a_t_a/cdata/; |
| $ret =~ s/_n_s$/_ns/; |
| # For DOMUIEvent |
| $ret =~ s/_u_i_/_ui_/; |
| # For initEvent |
| $ret =~ s/init_event/init/; |
| return $ret; |
| } |
| sub to_attribute_fetcher { |
| return to_attribute_accessor(@_, "get"); |
| } |
| sub to_attribute_setter { |
| return to_attribute_accessor(@_, "set"); |
| } |
| sub to_attribute_accessor { |
| my ($type, $af, $accessor) = @_; |
| my $prefix = get_prefix($type); |
| my $ret; |
| if (exists $special_attribute{$af}) { |
| $ret = $prefix."_".$accessor."_".$special_attribute{$af}; |
| } else { |
| $af =~ s/[A-Z]/_$&/g; |
| $af = lc $af; |
| $ret = $prefix."_".$accessor."_".$af; |
| } |
| $ret =~ s/h_t_m_l/html/; |
| return $ret; |
| } |
| sub to_attribute_cast { |
| my $type = shift; |
| my $ret = get_prefix($type); |
| $ret =~ s/h_t_m_l/html/; |
| return "(${ret} *)"; |
| } |
| sub get_prefix { |
| my $type = shift; |
| if (exists $special_prefix{$type}) { |
| $prefix = $special_prefix{$type}; |
| } else { |
| $type =~ s/[A-Z]/_$&/g; |
| $prefix = lc $type; |
| $prefix = "dom".$prefix; |
| } |
| return $prefix; |
| } |
| # This function remain unsed |
| sub get_suffix { |
| my $type = shift; |
| my $suffix = "default"; |
| if (exists $override_suffix{$type}) { |
| $suffix = $override_suffix{$type}; |
| } else { |
| $type =~ s/[A-Z]/_$&/g; |
| $suffix = lc $type; |
| $suffix = "dom".$suffix; |
| } |
| return $suffix; |
| } |
| #asserttions sometimes can contain sub-statements according the DTD. Like |
| #<assertEquals ..> |
| # <stat1 /> |
| # <stat2 /> |
| #</assertEquals> |
| # |
| # And assertion can contains assertions too! So, I use the assertion_stack |
| # to deal: |
| # |
| # when we encounter an assertion, we push $assertionName, "end", "start" to |
| # the stack, and when we encounter a statement, we examine the stack to see |
| # the top element, if it is: |
| # |
| # 1. "start", then we are in sub-statement of that assertion, and this is the |
| # the first sub-statement, so we should print a if (condtion==true) {, before |
| # print the real statement. |
| # 2. "end", then we are in sub-statement of that assertion, and we are not the |
| # first one, just print the statement. |
| # |
| # But after searching the whole testcases, I found no use of sub-statements of assertions. |
| # So, this function left unsed! |
| sub end_half_assertion { |
| my ($self, $name) = @_; |
| my $top = pop(@{$self->{assertion_stack}}); |
| if ($top eq "end") { |
| print "$self->{indent}"."}\n"; |
| } else { |
| if ($top eq "start") { |
| pop(@{$self->{assertion_stack}}); |
| pop(@{$self->{assertion_stack}}); |
| } |
| } |
| pop(@{$self->{assertion_stack}}); |
| } |
| ### Enclose an unsed function |
| ############################################################################################## |
| sub cleanup_domvar { |
| my ($self, $indent) = @_; |
| my $str = join($indent, reverse @{$self->{unref}}); |
| print $indent.$str."\n"; |
| } |
| sub cleanup_fail { |
| my ($self, $indent) = @_; |
| $self->cleanup_domstring($indent); |
| $self->cleanup_domvar($indent); |
| } |
| sub cleanup { |
| my $self = shift; |
| print "\n\n"; |
| $self->cleanup_domstring("\t"); |
| $self->cleanup_domvar("\t"); |
| print "\n\tprintf(\"PASS\");\n"; |
| print "\n\treturn 0;\n"; |
| print "\n\}\n"; |
| } |
| sub addto_cleanup { |
| my ($self, $var) = @_; |
| my $type = $self->{'var'}->{$var}; |
| if (not exists $no_unref{$type}) { |
| my $prefix = "dom_node"; |
| if (exists $unref_prefix{$type}) { |
| $prefix = $unref_prefix{$type}; |
| } |
| push(@{$self->{unref}}, $prefix."_unref(".$var.");\n"); |
| } |
| } |
| sub adjust_ignore { |
| my $ig = shift; |
| if ($ig eq "auto"){ |
| return "true"; |
| } |
| return $ig; |
| } |
| sub find_override { |
| my ($self, $func, $var, $expected) = @_; |
| my $vn = $self->{var}->{$var}; |
| # Deal with string types |
| if ($expected eq "DOMString") { |
| return $func."_domstring"; |
| } else { |
| if ($expected =~ /^\"/ or $self->{"var"}->{$expected} eq "char *") { |
| return $func."_string"; |
| } |
| } |
| if (exists $override_suffix{$vn}) { |
| $func = $func."_".$override_suffix{$vn} |
| } |
| return $func; |
| } |
| sub param_unref { |
| my ($self, $var) = @_; |
| my $type = $self->{'var'}->{$var}; |
| if (not exists $no_unref{$type}) { |
| my $prefix = "dom_node"; |
| if (exists $unref_prefix{$type}) { |
| $prefix = $unref_prefix{$type}; |
| } |
| print "\tif ($var != NULL) {\n"; |
| print "\t\t" . $prefix."_unref(".$var.");\n"; |
| print "\t\t$var = NULL;\n"; |
| print "\t}\n"; |
| } |
| foreach my $item (@{$self->{unref}}) { |
| $item =~ m/.*\((.*)\).*/; |
| if ($var eq $1) { |
| return 1; |
| } |
| } |
| foreach my $item (@{$self->{string_unref}}) { |
| if ($var eq $item) { |
| return 1; |
| } |
| } |
| return 0; |
| } |
| sub generate_domstring_interface { |
| my ($self, $en, $a) = @_; |
| switch ($en) { |
| case "length" { |
| print "$a->{'var'} = dom_string_length($a->{'obj'});"; |
| } |
| else { |
| die "Can't generate method/attribute $en for DOMString"; |
| } |
| } |
| } |
| 1; |
| /contrib/network/netsurf/libdom/test/Makefile |
|---|
| 0,0 → 1,66 |
| testutils_files := testutils/comparators.c;testutils/list.c;testutils/domtsasserts.c |
| testutils_files := $(testutils_files);testutils/utils.c;testutils/foreach.c;testutils/load.c |
| TESTCFLAGS := $(TESTCFLAGS) -I$(DIR) -I$(DIR)testutils -Ibindings/xml -Ibindings/hubbub -Wno-unused -fno-strict-aliasing |
| ALL_XML_TESTS := |
| # 1: Path to XML file |
| # 2: Fragment C file name |
| # 3: DTD file |
| # 4: Test name |
| define do_xml_test |
| ifeq ($$(WANT_TEST),yes) |
| $(DIR)$2: $(DIR)testcases/tests/$1 $(DIR)transform.pl $(DIR)DOMTSHandler.pm |
| $(VQ)$(ECHO) " XFORM: $1" |
| $(Q)$(PERL) $(DIR)transform.pl $(DIR)$3 $(DIR)testcases/tests/$(dir $1)/files $(DIR)testcases/tests/$1 > $(DIR)$2 |
| DIR_TEST_ITEMS := $$(DIR_TEST_ITEMS) $4:$2;$(testutils_files) |
| endif |
| DISTCLEAN_ITEMS := $$(DISTCLEAN_ITEMS) $(DIR)$2 |
| ALL_XML_TESTS := $$(ALL_XML_TESTS) $4 |
| endef |
| # 1: suite base |
| # 2: dtd for suite |
| define do_xml_suite |
| $(foreach XML,$(filter-out $1/metadata.xml,$(filter-out $1/alltests.xml,$(subst $(DIR)testcases/tests/,,$(wildcard $(DIR)testcases/tests/$1/*.xml)))),$(call do_xml_test,$(XML),$(subst /,_,$(XML:.xml=.c)),$2,$(subst /,_,$(XML:.xml=)))) |
| endef |
| # 1: test name |
| define write_index |
| $(Q)$(ECHO) "$1 $1" >> $@ |
| endef |
| $(DIR)INDEX: test/Makefile |
| $(VQ)$(ECHO) " INDEX: Making test index" |
| $(Q)$(ECHO) "#test desc dir" > $@ |
| $(foreach XMLTEST,$(sort $(ALL_XML_TESTS)),$(call write_index,$(XMLTEST))) |
| TEST_PREREQS := $(TEST_PREREQS) $(DIR)INDEX |
| # Include the level 1 core tests |
| $(eval $(call do_xml_suite,level1/core,dom1-interfaces.xml)) |
| # Include level 1 html tests |
| $(eval $(call do_xml_suite,level1/html,dom1-interfaces.xml)) |
| # Include the level 2 core tests |
| $(eval $(call do_xml_suite,level2/core,dom2-core-interface.xml)) |
| CLEAN_ITEMS := $(DIR)INDEX |
| include $(NSBUILD)/Makefile.subdir |
| /contrib/network/netsurf/libdom/test/build-test.sh |
|---|
| 0,0 → 1,31 |
| #!/bin/bash |
| # |
| # This is a simple script to recompile a C test file. |
| # Usage: |
| # This script is designed to run under test output directory. |
| # |
| # You should firstly run "run-test.sh", which will genrate a test output directory. In that |
| # directory, there are C source files and corresponding executables. |
| # |
| # ../../../build-test.sh some-test-converted-c-file.c |
| # |
| # This file is part of libdom test suite. |
| # Licensed under the MIT License, |
| # http://www.opensource.org/licenses/mit-license.php |
| # Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| src="testutils/comparators.c testutils/domtsasserts.c testutils/foreach.c testutils/list.c testutils/load.c testutils/utils.c testutils/domtscondition.c" |
| domdir="../build-Linux-Linux-debug-lib-static" |
| ldflags="-L$domdir -ldom -L/usr/local/lib -lwapcaplet -L/usr/lib -lxml2 -lhubbub -lparserutils" |
| #ldflags="-L/usr/lib -lm -lz -L$domdir -ldom -L/usr/local/lib -lwapcaplet -lxml2 -lhubbub -lparserutils" |
| cflags="-Itestutils/ -I../bindings/xml -I../include -I../bindings/hubbub -I/usr/local/include" |
| sf="$1"; |
| echo $sf; |
| cwd=$(pwd); |
| cd ../../../ |
| exe=${sf%%.c}; |
| cfile="$cwd"/"$sf"; |
| gcc -g $cflags $src $cfile $ldflags -o $exe; |
| mv $exe $cwd; |
| cd $cwd; |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /contrib/network/netsurf/libdom/test/dom1-interfaces.xml |
|---|
| 0,0 → 1,3665 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Document |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!--This file is an extract of interface definitions from Document Object Model (DOM) Level 1 Specification--> |
| <library> |
| <exception name="DOMException" id="ID-17189187"> |
| <descr> |
| <p>DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impossible to perform (either for logical reasons, because data is lost, or because the implementation has become unstable). In general, DOM methods return specific error values in ordinary processing situation, such as out-of-bound errors when using<code>NodeList</code>.</p> |
| <p>Implementations may raise other exceptions under other circumstances. For example, implementations may raise an implementation-dependent exception if a<code>null</code>argument is passed.</p> |
| <p>Some languages and object systems do not support the concept of exceptions. For such systems, error conditions may be indicated using native error reporting mechanisms. For some bindings, for example, methods may return error codes similar to those listed in the corresponding method descriptions.</p> |
| </descr> |
| <component id="ID-146F692A" name="code"> |
| <typename>unsigned short</typename> |
| </component> |
| </exception> |
| <group id="ID-258A00AF" name="ExceptionCode"> |
| <descr> |
| <p>An integer indicating the type of error generated.</p> |
| </descr> |
| <constant name="INDEX_SIZE_ERR" type="unsigned short" value="1"> |
| <descr> |
| <p>If index or size is negative, or greater than the allowed value</p> |
| </descr> |
| </constant> |
| <constant name="DOMSTRING_SIZE_ERR" type="unsigned short" value="2"> |
| <descr> |
| <p>If the specified range of text does not fit into a DOMString</p> |
| </descr> |
| </constant> |
| <constant name="HIERARCHY_REQUEST_ERR" type="unsigned short" value="3"> |
| <descr> |
| <p>If any node is inserted somewhere it doesn't belong</p> |
| </descr> |
| </constant> |
| <constant name="WRONG_DOCUMENT_ERR" type="unsigned short" value="4"> |
| <descr> |
| <p>If a node is used in a different document than the one that created it (that doesn't support it)</p> |
| </descr> |
| </constant> |
| <constant name="INVALID_CHARACTER_ERR" type="unsigned short" value="5"> |
| <descr> |
| <p>If an invalid character is specified, such as in a name.</p> |
| </descr> |
| </constant> |
| <constant name="NO_DATA_ALLOWED_ERR" type="unsigned short" value="6"> |
| <descr> |
| <p>If data is specified for a node which does not support data</p> |
| </descr> |
| </constant> |
| <constant name="NO_MODIFICATION_ALLOWED_ERR" type="unsigned short" value="7"> |
| <descr> |
| <p>If an attempt is made to modify an object where modifications are not allowed</p> |
| </descr> |
| </constant> |
| <constant name="NOT_FOUND_ERR" type="unsigned short" value="8"> |
| <descr> |
| <p>If an attempt was made to reference a node in a context where it does not exist</p> |
| </descr> |
| </constant> |
| <constant name="NOT_SUPPORTED_ERR" type="unsigned short" value="9"> |
| <descr> |
| <p>If the implementation does not support the type of object requested</p> |
| </descr> |
| </constant> |
| <constant name="INUSE_ATTRIBUTE_ERR" type="unsigned short" value="10"> |
| <descr> |
| <p>If an attempt is made to add an attribute that is already inuse elsewhere</p> |
| </descr> |
| </constant> |
| </group> |
| <interface name="DOMImplementation" id="ID-102161490"> |
| <descr> |
| <p>The<code>DOMImplementation</code>interface provides a number of methods for performing operations that are independent of any particular instance of the document object model.</p> |
| <p>The DOM Level 1 does not specify a way of creating a document instance, and hence document creation is an operation specific to an implementation. Future Levels of the DOM specification are expected to provide methods for creating documents directly.</p> |
| </descr> |
| <method name="hasFeature" id="ID-5CED94D7"> |
| <descr> |
| <p>Test if the DOM implementation implements a specific feature.</p> |
| </descr> |
| <parameters> |
| <param name="feature" type="DOMString" attr="in"> |
| <descr> |
| <p>The package name of the feature to test. In Level 1, the legal values are "HTML" and "XML" (case-insensitive).</p> |
| </descr> |
| </param> |
| <param name="version" type="DOMString" attr="in"> |
| <descr> |
| <p>This is the version number of the package name to test. In Level 1, this is the string "1.0". If the version is not specified, supporting any version of the feature will cause the method to return<code>true</code>.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="boolean"> |
| <descr> |
| <p> |
| <code>true</code>if the feature is implemented in the specified version,<code>false</code>otherwise.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="DocumentFragment" inherits="Node" id="ID-B63ED1A3"> |
| <descr> |
| <p> |
| <code>DocumentFragment</code>is a "lightweight" or "minimal"<code>Document</code>object. It is very common to want to be able to extract a portion of a document's tree or to create a new fragment of a document. Imagine implementing a user command like cut or rearranging a document by moving fragments around. It is desirable to have an object which can hold such fragments and it is quite natural to use a Node for this purpose. While it is true that a<code>Document</code>object could fulfil this role, a<code>Document</code>object can potentially be a heavyweight object, depending on the underlying implementation. What is really needed for this is a very lightweight object.<code>DocumentFragment</code>is such an object.</p> |
| <p>Furthermore, various operations -- such as inserting nodes as children of another<code>Node</code>-- may take<code>DocumentFragment</code>objects as arguments; this results in all the child nodes of the<code>DocumentFragment</code>being moved to the child list of this node.</p> |
| <p>The children of a<code>DocumentFragment</code>node are zero or more nodes representing the tops of any sub-trees defining the structure of the document.<code>DocumentFragment</code>nodes do not need to be well-formed XML documents (although they do need to follow the rules imposed upon well-formed XML parsed entities, which can have multiple top nodes). For example, a<code>DocumentFragment</code>might have only one child and that child node could be a<code>Text</code>node. Such a structure model represents neither an HTML document nor a well-formed XML document.</p> |
| <p>When a<code>DocumentFragment</code>is inserted into a<code>Document</code>(or indeed any other<code>Node</code>that may take children) the children of the<code>DocumentFragment</code>and not the<code>DocumentFragment</code>itself are inserted into the<code>Node</code>. This makes the<code>DocumentFragment</code>very useful when the user wishes to create nodes that are siblings; the<code>DocumentFragment</code>acts as the parent of these nodes so that the user can use the standard methods from the<code>Node</code>interface, such as<code>insertBefore()</code>and<code>appendChild()</code>.</p> |
| </descr> |
| </interface> |
| <interface name="Document" inherits="Node" id="i-Document"> |
| <descr> |
| <p>The<code>Document</code>interface represents the entire HTML or XML document. Conceptually, it is the root of the document tree, and provides the primary access to the document's data.</p> |
| <p>Since elements, text nodes, comments, processing instructions, etc. cannot exist outside the context of a<code>Document</code>, the<code>Document</code>interface also contains the factory methods needed to create these objects. The<code>Node</code>objects created have a<code>ownerDocument</code>attribute which associates them with the<code>Document</code>within whose context they were created.</p> |
| </descr> |
| <attribute readonly="yes" name="doctype" type="DocumentType" id="ID-B63ED1A31"> |
| <descr> |
| <p>The Document Type Declaration (see<code>DocumentType</code>) associated with this document. For HTML documents as well as XML documents without a document type declaration this returns<code>null</code>. The DOM Level 1 does not support editing the Document Type Declaration, therefore<code>docType</code>cannot be altered in any way.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" name="implementation" type="DOMImplementation" id="ID-1B793EBA"> |
| <descr> |
| <p>The<code>DOMImplementation</code>object that handles this document. A DOM application may use objects from multiple implementations.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" name="documentElement" type="Element" id="ID-87CD092"> |
| <descr> |
| <p>This is a convenience attribute that allows direct access to the child node that is the root element of the document. For HTML documents, this is the element with the tagName "HTML".</p> |
| </descr> |
| </attribute> |
| <method name="createElement" id="ID-2141741547"> |
| <descr> |
| <p>Creates an element of the type specified. Note that the instance returned implements the<xtermref href="ID-745549614" form="simple" show="embed" actuate="auto">Element</xtermref>interface, so attributes can be specified directly on the returned object.</p> |
| </descr> |
| <parameters> |
| <param name="tagName" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of the element type to instantiate. For XML, this is case-sensitive. For HTML, the<code>tagName</code>parameter may be provided in any case, but it must be mapped to the canonical uppercase form by the DOM implementation.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Element"> |
| <descr> |
| <p>A new<code>Element</code>object.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>INVALID_CHARACTER_ERR: Raised if the specified name contains an invalid character.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="createDocumentFragment" id="ID-35CB04B5"> |
| <descr> |
| <p>Creates an empty<code>DocumentFragment</code>object.</p> |
| </descr> |
| <parameters/> |
| <returns type="DocumentFragment"> |
| <descr> |
| <p>A new<code>DocumentFragment</code>.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="createTextNode" id="ID-1975348127"> |
| <descr> |
| <p>Creates a<code>Text</code>node given the specified string.</p> |
| </descr> |
| <parameters> |
| <param name="data" type="DOMString" attr="in"> |
| <descr> |
| <p>The data for the node.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Text"> |
| <descr> |
| <p>The new<code>Text</code>object.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="createComment" id="ID-1334481328"> |
| <descr> |
| <p>Creates a<code>Comment</code>node given the specified string.</p> |
| </descr> |
| <parameters> |
| <param name="data" type="DOMString" attr="in"> |
| <descr> |
| <p>The data for the node.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Comment"> |
| <descr> |
| <p>The new<code>Comment</code>object.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="createCDATASection" id="ID-D26C0AF8"> |
| <descr> |
| <p>Creates a<code>CDATASection</code>node whose value is the specified string.</p> |
| </descr> |
| <parameters> |
| <param name="data" type="DOMString" attr="in"> |
| <descr> |
| <p>The data for the<code>CDATASection</code>contents.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="CDATASection"> |
| <descr> |
| <p>The new<code>CDATASection</code>object.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="createProcessingInstruction" id="ID-135944439"> |
| <descr> |
| <p>Creates a<code>ProcessingInstruction</code>node given the specified name and data strings.</p> |
| </descr> |
| <parameters> |
| <param name="target" type="DOMString" attr="in"> |
| <descr> |
| <p>The target part of the processing instruction.</p> |
| </descr> |
| </param> |
| <param name="data" type="DOMString" attr="in"> |
| <descr> |
| <p>The data for the node.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="ProcessingInstruction"> |
| <descr> |
| <p>The new<code>ProcessingInstruction</code>object.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>INVALID_CHARACTER_ERR: Raised if an invalid character is specified.</p> |
| <p>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="createAttribute" id="ID-1084891198"> |
| <descr> |
| <p>Creates an<code>Attr</code>of the given name. Note that the<code>Attr</code>instance can then be set on an<code>Element</code>using the<code>setAttribute</code>method.</p> |
| </descr> |
| <parameters> |
| <param name="name" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of the attribute.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Attr"> |
| <descr> |
| <p>A new<code>Attr</code>object.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>INVALID_CHARACTER_ERR: Raised if the specified name contains an invalid character.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="createEntityReference" id="ID-392B75AE"> |
| <descr> |
| <p>Creates an EntityReference object.</p> |
| </descr> |
| <parameters> |
| <param name="name" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of the entity to reference.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="EntityReference"> |
| <descr> |
| <p>The new<code>EntityReference</code>object.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>INVALID_CHARACTER_ERR: Raised if the specified name contains an invalid character.</p> |
| <p>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="getElementsByTagName" id="ID-A6C9094"> |
| <descr> |
| <p>Returns a<code>NodeList</code>of all the<code>Element</code>s with a given tag name in the order in which they would be encountered in a preorder traversal of the<code>Document</code>tree.</p> |
| </descr> |
| <parameters> |
| <param name="tagname" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of the tag to match on. The special value "*" matches all tags.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="NodeList"> |
| <descr> |
| <p>A new<code>NodeList</code>object containing all the matched<code>Element</code>s.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="Node" id="ID-1950641247"> |
| <descr> |
| <p>The<code>Node</code>interface is the primary datatype for the entire Document Object Model. It represents a single node in the document tree. While all objects implementing the<code>Node</code>interface expose methods for dealing with children, not all objects implementing the<code>Node</code>interface may have children. For example,<code>Text</code>nodes may not have children, and adding children to such nodes results in a<code>DOMException</code>being raised.</p> |
| <p>The attributes<code>nodeName</code>,<code>nodeValue</code>and<code>attributes</code>are included as a mechanism to getat node information without casting down to the specific derived interface. In cases where there is no obvious mapping of these attributes for a specific<code>nodeType</code>(e.g.,<code>nodeValue</code>for an Element or<code>attributes</code>for a Comment), this returns<code>null</code>. Note that the specialized interfaces may contain additional and more convenient mechanisms to get and set the relevant information.</p> |
| </descr> |
| <group id="ID-1841493061" name="NodeType"> |
| <descr> |
| <p>An integer indicating which type of node this is.</p> |
| </descr> |
| <constant name="ELEMENT_NODE" type="unsigned short" value="1"> |
| <descr> |
| <p>The node is a<code>Element</code>.</p> |
| </descr> |
| </constant> |
| <constant name="ATTRIBUTE_NODE" type="unsigned short" value="2"> |
| <descr> |
| <p>The node is an<code>Attr</code>.</p> |
| </descr> |
| </constant> |
| <constant name="TEXT_NODE" type="unsigned short" value="3"> |
| <descr> |
| <p>The node is a<code>Text</code>node.</p> |
| </descr> |
| </constant> |
| <constant name="CDATA_SECTION_NODE" type="unsigned short" value="4"> |
| <descr> |
| <p>The node is a<code>CDATASection</code>.</p> |
| </descr> |
| </constant> |
| <constant name="ENTITY_REFERENCE_NODE" type="unsigned short" value="5"> |
| <descr> |
| <p>The node is an<code>EntityReference</code>.</p> |
| </descr> |
| </constant> |
| <constant name="ENTITY_NODE" type="unsigned short" value="6"> |
| <descr> |
| <p>The node is an<code>Entity</code>.</p> |
| </descr> |
| </constant> |
| <constant name="PROCESSING_INSTRUCTION_NODE" type="unsigned short" value="7"> |
| <descr> |
| <p>The node is a<code>ProcessingInstruction</code>.</p> |
| </descr> |
| </constant> |
| <constant name="COMMENT_NODE" type="unsigned short" value="8"> |
| <descr> |
| <p>The node is a<code>Comment</code>.</p> |
| </descr> |
| </constant> |
| <constant name="DOCUMENT_NODE" type="unsigned short" value="9"> |
| <descr> |
| <p>The node is a<code>Document</code>.</p> |
| </descr> |
| </constant> |
| <constant name="DOCUMENT_TYPE_NODE" type="unsigned short" value="10"> |
| <descr> |
| <p>The node is a<code>DocumentType</code>.</p> |
| </descr> |
| </constant> |
| <constant name="DOCUMENT_FRAGMENT_NODE" type="unsigned short" value="11"> |
| <descr> |
| <p>The node is a<code>DocumentFragment</code>.</p> |
| </descr> |
| </constant> |
| <constant name="NOTATION_NODE" type="unsigned short" value="12"> |
| <descr> |
| <p>The node is a<code>Notation</code>.</p> |
| </descr> |
| </constant> |
| </group> |
| <p>The values of<code>nodeName</code>,<code>nodeValue</code>, and<code>attributes</code>vary according to the node type as follows:<table border="1"> |
| <tbody> |
| <tr> |
| <td rowspan="1" colspan="1"/> |
| <td rowspan="1" colspan="1">nodeName</td> |
| <td rowspan="1" colspan="1">nodeValue</td> |
| <td rowspan="1" colspan="1">attributes</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">Element</td> |
| <td rowspan="1" colspan="1">tagName</td> |
| <td rowspan="1" colspan="1">null</td> |
| <td rowspan="1" colspan="1">NamedNodeMap</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">Attr</td> |
| <td rowspan="1" colspan="1">name of attribute</td> |
| <td rowspan="1" colspan="1">value of attribute</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">Text</td> |
| <td rowspan="1" colspan="1">#text</td> |
| <td rowspan="1" colspan="1">content of the text node</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">CDATASection</td> |
| <td rowspan="1" colspan="1">#cdata-section</td> |
| <td rowspan="1" colspan="1">content of the CDATA Section</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">EntityReference</td> |
| <td rowspan="1" colspan="1">name of entity referenced</td> |
| <td rowspan="1" colspan="1">null</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">Entity</td> |
| <td rowspan="1" colspan="1">entity name</td> |
| <td rowspan="1" colspan="1">null</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">ProcessingInstruction</td> |
| <td rowspan="1" colspan="1">target</td> |
| <td rowspan="1" colspan="1">entire content excluding the target</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">Comment</td> |
| <td rowspan="1" colspan="1">#comment</td> |
| <td rowspan="1" colspan="1">content of the comment</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">Document</td> |
| <td rowspan="1" colspan="1">#document</td> |
| <td rowspan="1" colspan="1">null</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">DocumentType</td> |
| <td rowspan="1" colspan="1">document type name</td> |
| <td rowspan="1" colspan="1">null</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">DocumentFragment</td> |
| <td rowspan="1" colspan="1">#document-fragment</td> |
| <td rowspan="1" colspan="1">null</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| <tr> |
| <td rowspan="1" colspan="1">Notation</td> |
| <td rowspan="1" colspan="1">notation name</td> |
| <td rowspan="1" colspan="1">null</td> |
| <td rowspan="1" colspan="1">null</td> |
| </tr> |
| </tbody> |
| </table> |
| </p> |
| <attribute type="DOMString" readonly="yes" name="nodeName" id="ID-F68D095"> |
| <descr> |
| <p>The name of this node, depending on its type; see the table above.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="nodeValue" id="ID-F68D080" readonly="no"> |
| <descr> |
| <p>The value of this node, depending on its type; see the table above.</p> |
| </descr> |
| <setraises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p> |
| </descr> |
| </exception> |
| </setraises> |
| <getraises> |
| <exception name="DOMException"> |
| <descr> |
| <p>DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a<code>DOMString</code>variable on the implementation platform.</p> |
| </descr> |
| </exception> |
| </getraises> |
| </attribute> |
| <attribute type="unsigned short" name="nodeType" readonly="yes" id="ID-111237558"> |
| <descr> |
| <p>A code representing the type of the underlying object, as defined above.</p> |
| </descr> |
| </attribute> |
| <attribute type="Node" readonly="yes" name="parentNode" id="ID-1060184317"> |
| <descr> |
| <p>The parent of this node. All nodes, except<code>Document</code>,<code>DocumentFragment</code>, and<code>Attr</code>may have a parent. However, if a node has just been created and not yet added to the tree, or if it has been removed from the tree, this is<code>null</code>.</p> |
| </descr> |
| </attribute> |
| <attribute type="NodeList" readonly="yes" name="childNodes" id="ID-1451460987"> |
| <descr> |
| <p>A<code>NodeList</code>that contains all children of this node. If there are no children, this is a<code>NodeList</code>containing no nodes. The content of the returned<code>NodeList</code>is "live" in the sense that, for instance, changes to the children of the node object that it was created from are immediately reflected in the nodes returned by the<code>NodeList</code>accessors; it is not a static snapshot of the content of the node. This is true for every<code>NodeList</code>, including the ones returned by the<code>getElementsByTagName</code>method.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="Node" name="firstChild" id="ID-169727388"> |
| <descr> |
| <p>The first child of this node. If there is no such node, this returns<code>null</code>.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="Node" name="lastChild" id="ID-61AD09FB"> |
| <descr> |
| <p>The last child of this node. If there is no such node, this returns<code>null</code>.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="Node" name="previousSibling" id="ID-640FB3C8"> |
| <descr> |
| <p>The node immediately preceding this node. If there is no such node, this returns<code>null</code>.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="Node" name="nextSibling" id="ID-6AC54C2F"> |
| <descr> |
| <p>The node immediately following this node. If there is no such node, this returns<code>null</code>.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="NamedNodeMap" name="attributes" id="ID-84CF096"> |
| <descr> |
| <p>A<code>NamedNodeMap</code>containing the attributes of this node (if it is an<code>Element</code>) or<code>null</code>otherwise.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="Document" name="ownerDocument" id="node-ownerDoc"> |
| <descr> |
| <p>The<code>Document</code>object associated with this node. This is also the<code>Document</code>object used to create new nodes. When this node is a<code>Document</code>this is<code>null</code>.</p> |
| </descr> |
| </attribute> |
| <method name="insertBefore" id="ID-952280727"> |
| <descr> |
| <p>Inserts the node<code>newChild</code>before the existing child node<code>refChild</code>. If<code>refChild</code>is<code>null</code>, insert<code>newChild</code>at the end of the list of children.</p> |
| <p>If<code>newChild</code>is a<code>DocumentFragment</code>object, all of its children are inserted, in the same order, before<code>refChild</code>. If the<code>newChild</code>is already in the tree, it is first removed.</p> |
| </descr> |
| <parameters> |
| <param name="newChild" type="Node" attr="in"> |
| <descr> |
| <p>The node to insert.</p> |
| </descr> |
| </param> |
| <param name="refChild" type="Node" attr="in"> |
| <descr> |
| <p>The reference node, i.e., the node before which the new node must be inserted.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>The node being inserted.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the<code>newChild</code>node, or if the node to insert is one of this node's ancestors.</p> |
| <p>WRONG_DOCUMENT_ERR: Raised if<code>newChild</code>was created from a different document than the one that created this node.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| <p>NOT_FOUND_ERR: Raised if<code>refChild</code>is not a child of this node.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="replaceChild" id="ID-785887307"> |
| <descr> |
| <p>Replaces the child node<code>oldChild</code>with<code>newChild</code>in the list of children, and returns the<code>oldChild</code>node. If the<code>newChild</code>is already in the tree, it is first removed.</p> |
| </descr> |
| <parameters> |
| <param name="newChild" type="Node" attr="in"> |
| <descr> |
| <p>The new node to put in the child list.</p> |
| </descr> |
| </param> |
| <param name="oldChild" type="Node" attr="in"> |
| <descr> |
| <p>The node being replaced in the list.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>The node replaced.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the<code>newChild</code>node, or it the node to put in is one of this node's ancestors.</p> |
| <p>WRONG_DOCUMENT_ERR: Raised if<code>newChild</code>was created from a different document than the one that created this node.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| <p>NOT_FOUND_ERR: Raised if<code>oldChild</code>is not a child of this node.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="removeChild" id="ID-1734834066"> |
| <descr> |
| <p>Removes the child node indicated by<code>oldChild</code>from the list of children, and returns it.</p> |
| </descr> |
| <parameters> |
| <param name="oldChild" type="Node" attr="in"> |
| <descr> |
| <p>The node being removed.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>The node removed.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| <p>NOT_FOUND_ERR: Raised if<code>oldChild</code>is not a child of this node.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="appendChild" id="ID-184E7107"> |
| <descr> |
| <p>Adds the node<code>newChild</code>to the end of the list of children of this node. If the<code>newChild</code>is already in the tree, it is first removed.</p> |
| </descr> |
| <parameters> |
| <param name="newChild" type="Node" attr="in"> |
| <descr> |
| <p>The node to add.</p> |
| <p>If it is a<code>DocumentFragment</code>object, the entire contents of the document fragment are moved into the child list of this node</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>The node added.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the<code>newChild</code>node, or if the node to append is one of this node's ancestors.</p> |
| <p>WRONG_DOCUMENT_ERR: Raised if<code>newChild</code>was created from a different document than the one that created this node.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="hasChildNodes" id="ID-810594187"> |
| <descr> |
| <p>This is a convenience method to allow easy determination of whether a node has any children.</p> |
| </descr> |
| <parameters/> |
| <returns type="boolean"> |
| <descr> |
| <p> |
| <code>true</code>if the node has any children,<code>false</code>if the node has no children.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="cloneNode" id="ID-3A0ED0A4"> |
| <descr> |
| <p>Returns a duplicate of this node, i.e., serves as a generic copy constructor for nodes. The duplicate node has no parent (<code>parentNode</code>returns<code>null</code>.).</p> |
| <p>Cloning an<code>Element</code>copies all attributes and their values, including those generated by the XML processor to represent defaulted attributes, but this method does not copy any text it contains unless it is a deep clone, since the text is contained in a child<code>Text</code>node. Cloning any other type of node simply returns a copy of this node.</p> |
| </descr> |
| <parameters> |
| <param name="deep" type="boolean" attr="in"> |
| <descr> |
| <p>If<code>true</code>, recursively clone the subtree under the specified node; if<code>false</code>, clone only the node itself (and its attributes, if it is an<code>Element</code>).</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>The duplicate node.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="NodeList" id="ID-536297177"> |
| <descr> |
| <p>The<code>NodeList</code>interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented.</p> |
| <p>The items in the<code>NodeList</code>are accessible via an integral index, starting from 0.</p> |
| </descr> |
| <method name="item" id="ID-844377136"> |
| <descr> |
| <p>Returns the<code>index</code>th item in the collection. If<code>index</code>is greater than or equal to the number of nodes in the list, this returns<code>null</code>.</p> |
| </descr> |
| <parameters> |
| <param name="index" type="unsigned long" attr="in"> |
| <descr> |
| <p>Index into the collection.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>The node atthe<code>index</code>th position in the<code>NodeList</code>, or<code>null</code>if that is not a valid index.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <attribute type="unsigned long" readonly="yes" name="length" id="ID-203510337"> |
| <descr> |
| <p>The number of nodes in the list. The range of valid child node indices is 0 to<code>length-1</code>inclusive.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="NamedNodeMap" inherits="" id="ID-1780488922"> |
| <descr> |
| <p>Objects implementing the<code>NamedNodeMap</code>interface are used to represent collections of nodes that can be accessed by name. Note that<code>NamedNodeMap</code>does not inherit from<code>NodeList</code>;<code>NamedNodeMap</code>s are not maintained in any particular order. Objects contained in an object implementing<code>NamedNodeMap</code>may also be accessed by an ordinal index, but this is simply to allow convenient enumeration of the contents of a<code>NamedNodeMap</code>, and does not imply that the DOM specifies an order to these Nodes.</p> |
| </descr> |
| <method name="getNamedItem" id="ID-1074577549"> |
| <descr> |
| <p>Retrieves a node specified by name.</p> |
| </descr> |
| <parameters> |
| <param name="name" type="DOMString" attr="in"> |
| <descr> |
| <p>Name of a node to retrieve.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>A<code>Node</code>(of any type) with the specified name, or<code>null</code>if the specified name did not identify any node in the map.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="setNamedItem" id="ID-1025163788"> |
| <descr> |
| <p>Adds a node using its<code>nodeName</code>attribute.</p> |
| <p>As the<code>nodeName</code>attribute is used to derive the name which the node must be stored under, multiple nodes of certain types (those that have a "special" string value) cannot be stored as the names would clash. This is seen as preferable to allowing nodes to be aliased.</p> |
| </descr> |
| <parameters> |
| <param name="arg" type="Node" attr="in"> |
| <descr> |
| <p>A node to store in a named node map. The node will later be accessible using the value of the<code>nodeName</code>attribute of the node. If a node with that name is already present in the map, it is replaced by the new one.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>If the new<code>Node</code>replaces an existing node with the same name the previously existing<code>Node</code>is returned, otherwise<code>null</code>is returned.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>WRONG_DOCUMENT_ERR: Raised if<code>arg</code>was created from a different document than the one that created the<code>NamedNodeMap</code>.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this<code>NamedNodeMap</code>is readonly.</p> |
| <p>INUSE_ATTRIBUTE_ERR: Raised if<code>arg</code>is an<code>Attr</code>that is already an attribute of another<code>Element</code>object. The DOM user must explicitly clone<code>Attr</code>nodes to re-use them in other elements.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="removeNamedItem" id="ID-D58B193"> |
| <descr> |
| <p>Removes a node specified by name. If the removed node is an<code>Attr</code>with a default value it is immediately replaced.</p> |
| </descr> |
| <parameters> |
| <param name="name" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of a node to remove.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>The node removed from the map or<code>null</code>if no node with such a name exists.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NOT_FOUND_ERR: Raised if there is no node named <code>name</code> in this map.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="item" id="ID-349467F9"> |
| <descr> |
| <p>Returns the<code>index</code>th item in the map. If<code>index</code>is greater than or equal to the number of nodes in the map, this returns<code>null</code>.</p> |
| </descr> |
| <parameters> |
| <param name="index" type="unsigned long" attr="in"> |
| <descr> |
| <p>Index into the map.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>The node at the<code>index</code>th position in the<code>NamedNodeMap</code>, or<code>null</code>if that is not a valid index.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <attribute type="unsigned long" readonly="yes" name="length" id="ID-6D0FB19E"> |
| <descr> |
| <p>The number of nodes in the map. The range of valid child node indices is 0 to<code>length-1</code>inclusive.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="CharacterData" inherits="Node" id="ID-FF21A306"> |
| <descr> |
| <p>The<code>CharacterData</code>interface extends Node with a set of attributes and methods for accessing character data in the DOM. For clarity this set is defined here rather than on each object that uses these attributes and methods. No DOM objects correspond directly to<code>CharacterData</code>, though<code>Text</code>and others do inherit the interface from it. All<code>offset</code>s in this interface start from 0.</p> |
| </descr> |
| <attribute type="DOMString" name="data" id="ID-72AB8359" readonly="no"> |
| <descr> |
| <p>The character data of the node that implements this interface. The DOM implementation may not put arbitrary limits on the amount of data that may be stored in a<code>CharacterData</code>node. However, implementation limits may mean that the entirety of a node's data may not fit into a single<code>DOMString</code>. In such cases, the user may call<code>substringData</code>to retrieve the data in appropriately sized pieces.</p> |
| </descr> |
| <setraises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p> |
| </descr> |
| </exception> |
| </setraises> |
| <getraises> |
| <exception name="DOMException"> |
| <descr> |
| <p>DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a<code>DOMString</code>variable on the implementation platform.</p> |
| </descr> |
| </exception> |
| </getraises> |
| </attribute> |
| <attribute type="unsigned long" name="length" readonly="yes" id="ID-7D61178C"> |
| <descr> |
| <p>The number of characters that are available through<code>data</code>and the<code>substringData</code>method below. This may have the value zero, i.e.,<code>CharacterData</code>nodes may be empty.</p> |
| </descr> |
| </attribute> |
| <method name="substringData" id="ID-6531BCCF"> |
| <descr> |
| <p>Extracts a range of data from the node.</p> |
| </descr> |
| <parameters> |
| <param name="offset" type="unsigned long" attr="in"> |
| <descr> |
| <p>Start offset of substring to extract.</p> |
| </descr> |
| </param> |
| <param name="count" type="unsigned long" attr="in"> |
| <descr> |
| <p>The number of characters to extract.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="DOMString"> |
| <descr> |
| <p>The specified substring. If the sum of<code>offset</code>and<code>count</code>exceeds the<code>length</code>, then all characters to the end of the data are returned.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of characters in<code>data</code>, or if the specified<code>count</code>is negative.</p> |
| <p>DOMSTRING_SIZE_ERR: Raised if the specified range of text does not fit into a<code>DOMString</code>.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="appendData" id="ID-32791A2F"> |
| <descr> |
| <p>Append the string to the end of the character data of the node. Upon success,<code>data</code>provides access to the concatenation of<code>data</code>and the<code>DOMString</code>specified.</p> |
| </descr> |
| <parameters> |
| <param name="arg" type="DOMString" attr="in"> |
| <descr> |
| <p>The<code>DOMString</code>to append.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="insertData" id="ID-3EDB695F"> |
| <descr> |
| <p>Insert a string at the specified character offset.</p> |
| </descr> |
| <parameters> |
| <param name="offset" type="unsigned long" attr="in"> |
| <descr> |
| <p>The character offset at which to insert.</p> |
| </descr> |
| </param> |
| <param name="arg" type="DOMString" attr="in"> |
| <descr> |
| <p>The<code>DOMString</code>to insert.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of characters in<code>data</code>.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="deleteData" id="ID-7C603781"> |
| <descr> |
| <p>Remove a range of characters from the node. Upon success,<code>data</code>and<code>length</code>reflect the change.</p> |
| </descr> |
| <parameters> |
| <param name="offset" type="unsigned long" attr="in"> |
| <descr> |
| <p>The offset from which to remove characters.</p> |
| </descr> |
| </param> |
| <param name="count" type="unsigned long" attr="in"> |
| <descr> |
| <p>The number of characters to delete. If the sum of<code>offset</code>and<code>count</code>exceeds<code>length</code>then all characters from<code>offset</code>to the end of the data are deleted.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of characters in<code>data</code>, or if the specified<code>count</code>is negative.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="replaceData" id="ID-E5CBA7FB"> |
| <descr> |
| <p>Replace the characters starting at the specified character offset with the specified string.</p> |
| </descr> |
| <parameters> |
| <param name="offset" type="unsigned long" attr="in"> |
| <descr> |
| <p>The offset from which to start replacing.</p> |
| </descr> |
| </param> |
| <param name="count" type="unsigned long" attr="in"> |
| <descr> |
| <p>The number of characters to replace. If the sum of<code>offset</code>and<code>count</code>exceeds<code>length</code>, then all characters to the end of the data are replaced (i.e., the effect is the same as a<code>remove</code>method call with the same range, followed by an<code>append</code>method invocation).</p> |
| </descr> |
| </param> |
| <param name="arg" type="DOMString" attr="in"> |
| <descr> |
| <p>The<code>DOMString</code>with which the range must be replaced.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of characters in<code>data</code>, or if the specified<code>count</code>is negative.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| </interface> |
| <interface name="Attr" inherits="Node" id="ID-637646024"> |
| <descr> |
| <p>The<code>Attr</code>interface represents an attribute in an<code>Element</code>object. Typically the allowable values for the attribute are defined in a document type definition.</p> |
| <p> |
| <code>Attr</code>objects inherit the<code>Node</code>interface, but since they are not actually child nodes of the element they describe, the DOM does not consider them part of the document tree. Thus, the<code>Node</code>attributes<code>parentNode</code>,<code>previousSibling</code>, and<code>nextSibling</code>have a null value for<code>Attr</code>objects. The DOM takes the view that attributes are properties of elements rather than having a separate identity from the elements they are associated with; this should make it more efficient to implement such features as default attributes associated with all elements of a given type. Furthermore,<code>Attr</code>nodes may not be immediate children of a<code>DocumentFragment</code>. However, they can be associated with<code>Element</code>nodes contained within a<code>DocumentFragment</code>. In short, users and implementors of the DOM need to be aware that<code>Attr</code>nodes have some things in common with other objects inheriting the<code>Node</code>interface, but they also are quite distinct.</p> |
| <p>The attribute's effective value is determined as follows: if this attribute has been explicitly assigned any value, that value is the attribute's effective value; otherwise, if there is a declaration for this attribute, and that declaration includes a default value, then that default value is the attribute's effective value; otherwise, the attribute does not exist on this element in the structure model until it has been explicitly added. Note that the<code>nodeValue</code>attribute on the<code>Attr</code>instance can also be used to retrieve the string version of the attribute's value(s).</p> |
| <p>In XML, where the value of an attribute can contain entity references, the child nodes of the<code>Attr</code>node provide a representation in which entity references are not expanded. These child nodes may be either<code>Text</code>or<code>EntityReference</code>nodes. Because the attribute type may be unknown, there are no tokenized attribute values.</p> |
| </descr> |
| <attribute type="DOMString" readonly="yes" name="name" id="ID-1112119403"> |
| <descr> |
| <p>Returns the name of this attribute.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" readonly="yes" name="specified" id="ID-862529273"> |
| <descr> |
| <p>If this attribute was explicitly given a value in the original document, this is<code>true</code>; otherwise, it is<code>false</code>. Note that the implementation is in charge of this attribute, not the user. If the user changes the value of the attribute (even if it ends up having the same value as the default value) then the<code>specified</code>flag is automatically flipped to<code>true</code>. To re-specify the attribute as the default value from the DTD, the user must delete the attribute. The implementation will then make a new attribute available with<code>specified</code>set to<code>false</code>and the default value (if one exists).</p> |
| <p>In summary:<ulist> |
| <item> |
| <p>If the attribute has an assigned value in the document then<code>specified</code>is<code>true</code>, and the value is the assigned value.</p> |
| </item> |
| <item> |
| <p>If the attribute has no assigned value in the document and has a default value in the DTD, then<code>specified</code>is<code>false</code>, and the value is the default value in the DTD.</p> |
| </item> |
| <item> |
| <p>If the attribute has no assigned value in the document and has a value of #IMPLIED in the DTD, then the attribute does not appear in the structure model of the document.</p> |
| </item> |
| </ulist> |
| </p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="value" id="ID-221662474" readonly="no"> |
| <descr> |
| <p>On retrieval, the value of the attribute is returned as a string. Character and general entity references are replaced with their values.</p> |
| <p>On setting, this creates a<code>Text</code>node with the unparsed contents of the string.</p> |
| </descr> |
| <setraises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p> |
| </descr> |
| </exception> |
| </setraises> |
| </attribute> |
| </interface> |
| <interface name="Element" inherits="Node" id="ID-745549614"> |
| <descr> |
| <p>By far the vast majority of objects (apart from text) that authors encounter when traversing a document are<code>Element</code>nodes. Assume the following XML document:<eg role="code" space="preserve"><elementExample id="demo"> <subelement1/> <subelement2><subsubelement/></subelement2> </elementExample></eg> |
| </p> |
| <p>When represented using DOM, the top node is an<code>Element</code>node for "elementExample", which contains two child<code>Element</code>nodes, one for "subelement1" and one for "subelement2". "subelement1" contains no child nodes.</p> |
| <p>Elements may have attributes associated with them; since the<code>Element</code>interface inherits from<code>Node</code>, the generic<code>Node</code>interface method<code>getAttributes</code>may be used to retrieve the set of all attributes for an element. There are methods on the<code>Element</code>interface to retrieve either an<code>Attr</code>object by name or an attribute value by name. In XML, where an attribute value may contain entity references, an<code>Attr</code>object should be retrieved to examine the possibly fairly complex sub-tree representing the attribute value. On the other hand, in HTML, where all attributes have simple string values, methods to directly access an attribute value can safely be used as a convenience.</p> |
| </descr> |
| <attribute type="DOMString" name="tagName" readonly="yes" id="ID-104682815"> |
| <descr> |
| <p>The name of the element. For example, in:<eg role="code" space="preserve"><elementExample id="demo"> ... </elementExample> ,</eg> |
| <code>tagName</code>has the value<code>"elementExample"</code>. Note that this is case-preserving in XML, as are all of the operations of the DOM. The HTML DOM returns the<code>tagName</code>of an HTML element in the canonical uppercase form, regardless of the case in the source HTML document.</p> |
| </descr> |
| </attribute> |
| <method name="getAttribute" id="ID-666EE0F9"> |
| <descr> |
| <p>Retrieves an attribute value by name.</p> |
| </descr> |
| <parameters> |
| <param name="name" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of the attribute to retrieve.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="DOMString"> |
| <descr> |
| <p>The<code>Attr</code>value as a string, or the empty string if that attribute does not have a specified or default value.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="setAttribute" id="ID-F68F082"> |
| <descr> |
| <p>Adds a new attribute. If an attribute with that name is already present in the element, its value is changed to be that of the value parameter. This value is a simple string, it is not parsed as it is being set. So any markup (such as syntax to be recognized as an entity reference) is treated as literal text, and needs to be appropriately escaped by the implementation when it is written out. In order to assign an attribute value that contains entity references, the user must create an<code>Attr</code>node plus any<code>Text</code>and<code>EntityReference</code>nodes, build the appropriate subtree, and use<code>setAttributeNode</code>to assign it as the value of an attribute.</p> |
| </descr> |
| <parameters> |
| <param name="name" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of the attribute to create or alter.</p> |
| </descr> |
| </param> |
| <param name="value" type="DOMString" attr="in"> |
| <descr> |
| <p>Value to set in string form.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>INVALID_CHARACTER_ERR: Raised if the specified name contains an invalid character.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="removeAttribute" id="ID-6D6AC0F9"> |
| <descr> |
| <p>Removes an attribute by name. If the removed attribute has a default value it is immediately replaced.</p> |
| </descr> |
| <parameters> |
| <param name="name" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of the attribute to remove.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="getAttributeNode" id="ID-217A91B8"> |
| <descr> |
| <p>Retrieves an<code>Attr</code>node by name.</p> |
| </descr> |
| <parameters> |
| <param name="name" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of the attribute to retrieve.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Attr"> |
| <descr> |
| <p>The<code>Attr</code>node with the specified attribute name or<code>null</code>if there is no such attribute.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="setAttributeNode" id="ID-887236154"> |
| <descr> |
| <p>Adds a new attribute. If an attribute with that name is already present in the element, it is replaced by the new one.</p> |
| </descr> |
| <parameters> |
| <param name="newAttr" type="Attr" attr="in"> |
| <descr> |
| <p>The<code>Attr</code>node to add to the attribute list.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Attr"> |
| <descr> |
| <p>If the<code>newAttr</code>attribute replaces an existing attribute with the same name, the previously existing<code>Attr</code>node is returned, otherwise<code>null</code>is returned.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>WRONG_DOCUMENT_ERR: Raised if<code>newAttr</code>was created from a different document than the one that created the element.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| <p>INUSE_ATTRIBUTE_ERR: Raised if<code>newAttr</code>is already an attribute of another<code>Element</code>object. The DOM user must explicitly clone<code>Attr</code>nodes to re-use them in other elements.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="removeAttributeNode" id="ID-D589198"> |
| <descr> |
| <p>Removes the specified attribute.</p> |
| </descr> |
| <parameters> |
| <param name="oldAttr" type="Attr" attr="in"> |
| <descr> |
| <p>The<code>Attr</code>node to remove from the attribute list. If the removed<code>Attr</code>has a default value it is immediately replaced.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Attr"> |
| <descr> |
| <p>The<code>Attr</code>node that was removed.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| <p>NOT_FOUND_ERR: Raised if<code>oldAttr</code>is not an attribute of the element.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="getElementsByTagName" id="ID-1938918D"> |
| <descr> |
| <p>Returns a<code>NodeList</code>of all descendant elements with a given tag name, in the order in which they would be encountered in a preorder traversal of the<code>Element</code>tree.</p> |
| </descr> |
| <parameters> |
| <param name="tagname" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of the tag to match on. The special value "*" matches all tags.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="NodeList"> |
| <descr> |
| <p>A list of matching<code>Element</code>nodes.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="normalize" id="ID-162CF083"> |
| <descr> |
| <p>Puts all<code>Text</code>nodes in the full depth of the sub-tree underneath this<code>Element</code>into a "normal" form where only markup (e.g., tags, comments, processing instructions, CDATA sections, and entity references) separates<code>Text</code>nodes, i.e., there are no adjacent<code>Text</code>nodes. This can be used to ensure that the DOM view of a document is the same as if it were saved and re-loaded, and is useful when operations (such as XPointer lookups) that depend on a particular document tree structure are to be used.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="Text" inherits="CharacterData" id="ID-1312295772"> |
| <descr> |
| <p>The<code>Text</code>interface represents the textual content (termed<loc href="http://www.w3.org/TR/REC-xml#syntax" form="simple" show="embed" actuate="auto">characterdata</loc>in XML) of an<code>Element</code>or<code>Attr</code>. If there is no markup inside an element's content, the text is contained in a single object implementing the<code>Text</code>interface that is the only child of the element. If there is markup, it is parsed into a list of elements and<code>Text</code>nodes that form the list of children of the element.</p> |
| <p>When a document is first made available via the DOM, there is only one<code>Text</code>node for each block of text. Users may create adjacent<code>Text</code>nodes that represent the contents of a given element without any intervening markup, but should be aware that there is no way to represent the separations between these nodes in XML or HTML, so they will not (in general) persist between DOM editing sessions. The<code>normalize()</code>method on<code>Element</code>merges any such adjacent<code>Text</code>objects into a single node for each block of text; this is recommended before employing operations that depend on a particular document structure, such as navigation with<code>XPointers.</code> |
| </p> |
| </descr> |
| <method name="splitText" id="ID-38853C1D"> |
| <descr> |
| <p>Breaks this<code>Text</code>node into two Text nodes at the specified offset, keeping both in the tree as siblings. This node then only contains all the content up to the<code>offset</code>point. And a new<code>Text</code>node, which is inserted as the next sibling of this node, contains all the content at and after the<code>offset</code>point.</p> |
| </descr> |
| <parameters> |
| <param name="offset" type="unsigned long" attr="in"> |
| <descr> |
| <p>The offset at which to split, starting from 0.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Text"> |
| <descr> |
| <p>The new<code>Text</code>node.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of characters in<code>data</code>.</p> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| </interface> |
| <interface name="Comment" inherits="CharacterData" id="ID-1728279322"> |
| <descr> |
| <p>This represents the content of a comment, i.e., all the characters between the starting '<code><!--</code>' and ending '<code>--></code>'. Note that this is the definition of a comment in XML, and, in practice, HTML, although some HTML tools may implement the full SGML comment structure.</p> |
| </descr> |
| </interface> |
| <interface name="CDATASection" inherits="Text" id="ID-667469212"> |
| <descr> |
| <p>CDATA sections are used to escape blocks of text containing characters that would otherwise be regarded as markup. The only delimiter that is recognized in a CDATA section is the "]]>" string that ends the CDATA section. CDATA sections can not be nested. The primary purpose is for including material such as XML fragments, without needing to escape all the delimiters.</p> |
| <p>The<code>DOMString</code>attribute of the<code>Text</code>node holds the text that is contained by the CDATA section. Note that this<emph>may</emph>contain characters that need to be escaped outside of CDATA sections and that, depending on the character encoding ("charset") chosen for serialization, it may be impossible to write out some characters as part of a CDATA section.</p> |
| <p>The<code>CDATASection</code>interface inherits the<code>CharacterData</code>interface through the<code>Text</code>interface. Adjacent<code>CDATASections</code>nodes are not merged by use of the Element.normalize() method.</p> |
| </descr> |
| </interface> |
| <interface name="DocumentType" inherits="Node" id="ID-412266927"> |
| <descr> |
| <p>Each<code>Document</code>has a<code>doctype</code>attribute whose value is either<code>null</code>or a<code>DocumentType</code>object. The<code>DocumentType</code>interface in the DOM Level 1 Core provides an interface to the list of entities that are defined for the document, and little else because the effect of namespaces and the various XML scheme efforts on DTD representation are not clearly understood as of this writing.</p> |
| <p>The DOM Level 1 doesn't support editing<code>DocumentType</code>nodes.</p> |
| </descr> |
| <attribute readonly="yes" name="name" type="DOMString" id="ID-1844763134"> |
| <descr> |
| <p>The name of DTD; i.e., the name immediately following the<code>DOCTYPE</code>keyword.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" name="entities" type="NamedNodeMap" id="ID-1788794630"> |
| <descr> |
| <p>A<code>NamedNodeMap</code>containing the general entities, both external and internal, declared in the DTD. Duplicates are discarded. For example in:<eg role="code" space="preserve"><!DOCTYPE ex SYSTEM "ex.dtd" [ <!ENTITY foo "foo"> <!ENTITY bar "bar"> <!ENTITY % baz "baz"> ]> <ex/></eg>the interface provides access to<code>foo</code>and<code>bar</code>but not<code>baz</code>. Every node in this map also implements the<code>Entity</code>interface.</p> |
| <p>The DOM Level 1 does not support editing entities, therefore<code>entities</code>cannot be altered in any way.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" name="notations" type="NamedNodeMap" id="ID-D46829EF"> |
| <descr> |
| <p>A<code>NamedNodeMap</code>containing the notations declared in the DTD. Duplicates are discarded. Every node in this map also implements the<code>Notation</code>interface.</p> |
| <p>The DOM Level 1 does not support editing notations, therefore<code>notations</code>cannot be altered in any way.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="Notation" inherits="Node" id="ID-5431D1B9"> |
| <descr> |
| <p>This interface represents a notation declared in the DTD. A notation either declares, by name, the format of an unparsed entity (see section 4.7 of the XML 1.0 specification), or is used for formal declaration of Processing Instruction targets (see section 2.6 of the XML 1.0 specification). The<code>nodeName</code>attribute inherited from<code>Node</code>is set to the declared name of the notation.</p> |
| <p>The DOM Level 1 does not support editing<code>Notation</code>nodes; they are therefore readonly.</p> |
| <p>A<code>Notation</code>node does not have any parent.</p> |
| </descr> |
| <attribute readonly="yes" name="publicId" type="DOMString" id="ID-54F2B4D0"> |
| <descr> |
| <p>The public identifier of this notation. If the public identifier was not specified, this is<code>null</code>.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" name="systemId" type="DOMString" id="ID-E8AAB1D0"> |
| <descr> |
| <p>The system identifier of this notation. If the system identifier was not specified, this is<code>null</code>.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="Entity" inherits="Node" id="ID-527DCFF2"> |
| <descr> |
| <p>This interface represents an entity, either parsed or unparsed, in an XML document. Note that this models the entity itself<emph>not</emph>the entity declaration.<code>Entity</code>declaration modeling has been left for a later Level of the DOM specification.</p> |
| <p>The<code>nodeName</code>attribute that is inherited from<code>Node</code>contains the name of the entity.</p> |
| <p>An XML processor may choose to completely expand entities before the structure model is passed to the DOM; in this case there will be no<code>EntityReference</code>nodes in the document tree.</p> |
| <p>XML does not mandate that a non-validating XML processor read and process entity declarations made in the external subset or declared in external parameter entities. This means that parsed entities declared in the external subset need not be expanded by some classes of applications, and that the replacement value of the entity may not be available. When the replacement value is available, the corresponding<code>Entity</code>node's child list represents the structure of that replacement text. Otherwise, the child list is empty.</p> |
| <p>The resolution of the children of the<code>Entity</code>(the replacement value) may be lazily evaluated; actions by the user (such as calling the<code>childNodes</code>method on the<code>Entity</code>Node) are assumed to trigger the evaluation.</p> |
| <p>The DOM Level 1 does not support editing<code>Entity</code>nodes; if a user wants to make changes to the contents of an<code>Entity</code>, every related<code>EntityReference</code>node has to be replaced in the structure model by a clone of the<code>Entity</code>'s contents, and then the desired changes must be made to each of those clones instead. All the descendants of an<code>Entity</code>node are readonly.</p> |
| <p>An<code>Entity</code>node does not have any parent.</p> |
| </descr> |
| <attribute readonly="yes" name="publicId" type="DOMString" id="ID-D7303025"> |
| <descr> |
| <p>The public identifier associated with the entity, if specified. If the public identifier was not specified, this is<code>null</code>.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" name="systemId" type="DOMString" id="ID-D7C29F3E"> |
| <descr> |
| <p>The system identifier associated with the entity, if specified. If the system identifier was not specified, this is<code>null</code>.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" name="notationName" type="DOMString" id="ID-6ABAEB38"> |
| <descr> |
| <p>For unparsed entities, the name of the notation for the entity. For parsed entities, this is<code>null</code>.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="EntityReference" inherits="Node" id="ID-11C98490"> |
| <descr> |
| <p> |
| <code>EntityReference</code>objects may be inserted into the structure model when an entity reference is in the source document, or when the user wishes to insert an entity reference. Note that character references and references to predefined entities are considered to be expanded by the HTML or XML processor so that characters are represented by their Unicode equivalent rather than by an entity reference. Moreover, the XMLprocessor may completely expand references to entities while building the structure model, instead of providing<code>EntityReference</code>objects. If it does provide such objects, then for a given<code>EntityReference</code>node, it may be that there is no<code>Entity</code>node representing the referenced entity; but if such an<code>Entity</code>exists, then the child list of the<code>EntityReference</code>node is the same as that of the<code>Entity</code>node. As with the<code>Entity</code>node, all descendants of the<code>EntityReference</code>are readonly.</p> |
| <p>The resolution of the children of the<code>EntityReference</code>(the replacement value of the referenced<code>Entity</code>) may be lazily evaluated; actions by the user (such as calling the<code>childNodes</code>method on the<code>EntityReference</code>node) are assumed to trigger the evaluation.</p> |
| </descr> |
| </interface> |
| <interface name="ProcessingInstruction" inherits="Node" id="ID-1004215813"> |
| <descr> |
| <p>The<code>ProcessingInstruction</code>interface represents a "processing instruction", used in XML as a way to keep processor-specific information in the text of the document.</p> |
| </descr> |
| <attribute readonly="yes" type="DOMString" name="target" id="ID-1478689192"> |
| <descr> |
| <p>The target of this processing instruction. XML defines this as being the first token following the markup that begins the processing instruction.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="data" id="ID-837822393" readonly="no"> |
| <descr> |
| <p>The content of this processing instruction. This is from the first non white space character after the target to the character immediately preceding the<code>?></code>.</p> |
| </descr> |
| <setraises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p> |
| </descr> |
| </exception> |
| </setraises> |
| </attribute> |
| </interface> |
| <interface name="HTMLCollection" id="ID-75708506"> |
| <descr> |
| <p>An<code>HTMLCollection</code>is a list of nodes. An individual node may be accessed by either ordinal index or the node's<code>name</code>or<code>id</code>attributes.<emph>Note:</emph>Collections in the HTML DOM are assumed to be<emph>live</emph>meaning that they are automatically updated when the underlying document is changed.</p> |
| </descr> |
| <attribute readonly="yes" type="unsigned long" name="length" id="ID-40057551"> |
| <descr> |
| <p>This attribute specifies the length or<emph>size</emph>of the list.</p> |
| </descr> |
| </attribute> |
| <method name="item" id="ID-33262535"> |
| <descr> |
| <p>This method retrieves a node specified by ordinal index. Nodes are numbered in tree order (depth-first traversal order).</p> |
| </descr> |
| <parameters> |
| <param id="ID-3496656" name="index" type="unsigned long" attr="in"> |
| <descr> |
| <p>The index of the node to be fetched. The index origin is 0.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>The<code>Node</code>at the corresponding position upon success. A value of<code>null</code>is returned if the index is out of range.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="namedItem" id="ID-21069976"> |
| <descr> |
| <p>This method retrieves a<code>Node</code>using a name. It first searches for a<code>Node</code>with a matching<code>id</code>attribute. If it doesn't find one, it then searches for a<code>Node</code>with a matching<code>name</code>attribute, but only on those elements that are allowed a name attribute.</p> |
| </descr> |
| <parameters> |
| <param id="ID-76682631" name="name" type="DOMString" attr="in"> |
| <descr> |
| <p>The name of the<code>Node</code>to be fetched.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Node"> |
| <descr> |
| <p>The<code>Node</code>with a<code>name</code>or<code>id</code>attribute whose value corresponds to the specified string. Upon failure (e.g., no node with this name exists), returns<code>null</code>.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="HTMLDocument" inherits="Document" id="ID-26809268"> |
| <descr> |
| <p>An<code>HTMLDocument</code>is the root of the HTML hierarchy and holds the entire content. Beside providing access to the hierarchy, it also provides some convenience methods for accessing certain sets of information from the document.</p> |
| <p>The following properties have been deprecated in favor of the corresponding ones for the BODY element:</p> |
| <ulist> |
| <item> |
| <p>alinkColor</p> |
| </item> |
| <item> |
| <p>background</p> |
| </item> |
| <item> |
| <p>bgColor</p> |
| </item> |
| <item> |
| <p>fgColor</p> |
| </item> |
| <item> |
| <p>linkColor</p> |
| </item> |
| <item> |
| <p>vlinkColor</p> |
| </item> |
| </ulist> |
| <p/> |
| </descr> |
| <attribute type="DOMString" name="title" id="ID-18446827" readonly="no"> |
| <descr> |
| <p>The title of a document as specified by the<code>TITLE</code>element in the head of the document.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="DOMString" name="referrer" id="ID-95229140"> |
| <descr> |
| <p>Returns the URI of the page that linked to this page. The value is an empty string if the user navigated to the page directly (not through a link, but, for example, via a bookmark).</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="DOMString" name="domain" id="ID-2250147"> |
| <descr> |
| <p>The domain name of the server that served the document, or a null string if the server cannot be identified by a domain name.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="DOMString" name="URL" id="ID-46183437"> |
| <descr> |
| <p>The complete URI of the document.</p> |
| </descr> |
| </attribute> |
| <attribute type="HTMLElement" name="body" id="ID-56360201" readonly="no"> |
| <descr> |
| <p>The element that contains the content for the document. In documents with<code>BODY</code>contents, returns the<code>BODY</code>element, and in frameset documents, this returns the outermost<code>FRAMESET</code>element.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLCollection" name="images" id="ID-90379117"> |
| <descr> |
| <p>A collection of all the<code>IMG</code>elements in a document. The behavior is limited to<code>IMG</code>elements for backwards compatibility.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLCollection" name="applets" id="ID-85113862"> |
| <descr> |
| <p>A collection of all the<code>OBJECT</code>elements that include applets and<code>APPLET</code>(<emph>deprecated</emph>) elements in a document.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLCollection" name="links" id="ID-7068919"> |
| <descr> |
| <p>A collection of all<code>AREA</code>elements and anchor (<code>A</code>) elements in a document with a value for the<code>href</code>attribute.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLCollection" name="forms" id="ID-1689064"> |
| <descr> |
| <p>A collection of all the forms of a document.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLCollection" name="anchors" id="ID-7577272"> |
| <descr> |
| <p>A collection of all the anchor (<code>A</code>) elements in a document with a value for the<code>name</code>attribute.<emph>Note.</emph>For reasons of backwards compatibility, the returned set of anchors only contains those anchors created with the<code>name</code>attribute, not those created with the<code>id</code>attribute.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="cookie" id="ID-8747038" readonly="no"> |
| <descr> |
| <p>The cookies associated with this document. If there are none, the value is an empty string. Otherwise, the value is a string: a semicolon-delimited list of "name, value" pairs for all the cookies associated with the page. For example,<code>name=value;expires=date</code>.</p> |
| </descr> |
| </attribute> |
| <method name="open" id="ID-72161170"> |
| <descr> |
| <p> |
| <emph>Note.</emph>This method and the ones following allow a user to add to or replace the structure model of a document using strings of unparsed HTML. At the time of writing alternate methods for providing similar functionality for both HTML and XML documents were being considered. The following methods may be deprecated at some point in the future in favor of a more general-purpose mechanism.</p> |
| <p>Open a document stream for writing. If a document exists in the target, this method clears it.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="close" id="ID-98948567"> |
| <descr> |
| <p>Closes a document stream opened by<code>open()</code>and forces rendering.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="write" id="ID-75233634"> |
| <descr> |
| <p>Write a string of text to a document stream opened by<code>open()</code>. The text is parsed into the document's structure model.</p> |
| </descr> |
| <parameters> |
| <param id="ID-68980829" name="text" type="DOMString" attr="in"> |
| <descr> |
| <p>The string to be parsed into some structure in the document structure model.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="writeln" id="ID-35318390"> |
| <descr> |
| <p>Write a string of text followed by a newline character to a document stream opened by<code>open()</code>. The text is parsed into the document's structure model.</p> |
| </descr> |
| <parameters> |
| <param id="ID-19167591" name="text" type="DOMString" attr="in"> |
| <descr> |
| <p>The string to be parsed into some structure in the document structure model.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="getElementById" id="ID-36113835"> |
| <descr> |
| <p>Returns the Element whose<code>id</code>is given by elementId. If no such element exists, returns<code>null</code>. Behavior is not defined if more than one element has this<code>id</code>.</p> |
| </descr> |
| <parameters> |
| <param id="ID-9998411" name="elementId" type="DOMString" attr="in"> |
| <descr> |
| <p>The unique<code>id</code>value for an element.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Element"> |
| <descr> |
| <p>The matching element.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="getElementsByName" id="ID-71555259"> |
| <descr> |
| <p>Returns the (possibly empty) collection of elements whose<code>name</code>value is given by<code>elementName</code>.</p> |
| </descr> |
| <parameters> |
| <param id="ID-81610098" name="elementName" type="DOMString" attr="in"> |
| <descr> |
| <p>The<code>name</code>attribute value for an element.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="NodeList"> |
| <descr> |
| <p>The matching elements.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="HTMLElement" inherits="Element" id="ID-58190037"> |
| <descr> |
| <p>All HTML element interfaces derive from this class. Elements that only expose the HTML core attributes are represented by the base<code>HTMLElement</code>interface. These elements are as follows:</p> |
| <ulist> |
| <item> |
| <p>HEAD</p> |
| </item> |
| <item> |
| <p>special: SUB, SUP, SPAN, BDO</p> |
| </item> |
| <item> |
| <p>font: TT, I, B, U, S, STRIKE, BIG, SMALL</p> |
| </item> |
| <item> |
| <p>phrase: EM, STRONG, DFN, CODE, SAMP, KBD, VAR, CITE, ACRONYM, ABBR</p> |
| </item> |
| <item> |
| <p>list: DD, DT</p> |
| </item> |
| <item> |
| <p>NOFRAMES, NOSCRIPT</p> |
| </item> |
| <item> |
| <p>ADDRESS, CENTER</p> |
| </item> |
| </ulist> |
| <p> |
| <emph>Note.</emph>The<code>style</code>attribute for this interface is reserved for future usage.</p> |
| </descr> |
| <attribute type="DOMString" name="id" id="ID-63534901" readonly="no"> |
| <descr> |
| <p>The element's identifier. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-id" form="simple" show="embed" actuate="auto">id attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="title" id="ID-78276800" readonly="no"> |
| <descr> |
| <p>The element's advisory title. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-title" form="simple" show="embed" actuate="auto">title attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="lang" id="ID-59132807" readonly="no"> |
| <descr> |
| <p>Language code defined in RFC 1766. See the<loc href="http://www.w3.org/TR/REC-html40/struct/dirlang.html#adef-lang" form="simple" show="embed" actuate="auto">lang attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="dir" id="ID-52460740" readonly="no"> |
| <descr> |
| <p>Specifies the base direction of directionally neutral text and the directionality of tables. See the<loc href="http://www.w3.org/TR/REC-html40/struct/dirlang.html#adef-dir" form="simple" show="embed" actuate="auto">dir attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="className" id="ID-95362176" readonly="no"> |
| <descr> |
| <p>The class attribute of the element. This attribute has been renamed due to conflicts with the "class" keyword exposed by many languages. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-class" form="simple" show="embed" actuate="auto">class attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLHtmlElement" inherits="HTMLElement" id="ID-33759296"> |
| <descr> |
| <p>Root of an HTML document. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#edef-HTML" form="simple" show="embed" actuate="auto">HTML element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="version" id="ID-9383775" readonly="no"> |
| <descr> |
| <p>Version information about the document's DTD. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-version" form="simple" show="embed" actuate="auto">version attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLHeadElement" inherits="HTMLElement" id="ID-77253168"> |
| <descr> |
| <p>Document head information. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#edef-HEAD" form="simple" show="embed" actuate="auto">HEAD element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="profile" id="ID-96921909" readonly="no"> |
| <descr> |
| <p>URI designating a metadata profile. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-profile" form="simple" show="embed" actuate="auto">profile attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLLinkElement" inherits="HTMLElement" id="ID-35143001"> |
| <descr> |
| <p>The<code>LINK</code>element specifies a link to an external resource, and defines this document's relationship to that resource (or vice versa). See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#edef-LINK" form="simple" show="embed" actuate="auto">LINK element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="boolean" name="disabled" id="ID-87355129" readonly="no"> |
| <descr> |
| <p>Enables/disables the link. This is currently only used for style sheet links, and may be used to activate or deactivate style sheets.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="charset" id="ID-63954491" readonly="no"> |
| <descr> |
| <p>The character encoding of the resource being linked to. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-charset" form="simple" show="embed" actuate="auto">charset attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="href" id="ID-33532588" readonly="no"> |
| <descr> |
| <p>The URI of the linked resource. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-href" form="simple" show="embed" actuate="auto">href attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="hreflang" id="ID-85145682" readonly="no"> |
| <descr> |
| <p>Language code of the linked resource. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-hreflang" form="simple" show="embed" actuate="auto">hreflang attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="media" id="ID-75813125" readonly="no"> |
| <descr> |
| <p>Designed for use with one or more target media. See the<loc href="http://www.w3.org/TR/REC-html40/present/styles.html#adef-media" form="simple" show="embed" actuate="auto">media attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="rel" id="ID-41369587" readonly="no"> |
| <descr> |
| <p>Forward link type. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-rel" form="simple" show="embed" actuate="auto">rel attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="rev" id="ID-40715461" readonly="no"> |
| <descr> |
| <p>Reverse link type. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-rev" form="simple" show="embed" actuate="auto">rev attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="target" id="ID-84183095" readonly="no"> |
| <descr> |
| <p>Frame to render the resource in. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-target" form="simple" show="embed" actuate="auto">target attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="type" id="ID-32498296" readonly="no"> |
| <descr> |
| <p>Advisory content type. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-type-A" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLTitleElement" inherits="HTMLElement" id="ID-79243169"> |
| <descr> |
| <p>The document title. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#edef-TITLE" form="simple" show="embed" actuate="auto">TITLE element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="text" id="ID-77500413" readonly="no"> |
| <descr> |
| <p>The specified title as a string.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLMetaElement" inherits="HTMLElement" id="ID-37041454"> |
| <descr> |
| <p>This contains generic meta-information about the document. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#edef-META" form="simple" show="embed" actuate="auto">META element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="content" id="ID-87670826" readonly="no"> |
| <descr> |
| <p>Associated information. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-content" form="simple" show="embed" actuate="auto">content attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="httpEquiv" id="ID-77289449" readonly="no"> |
| <descr> |
| <p>HTTP response header name. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-http-equiv" form="simple" show="embed" actuate="auto">http-equiv attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-31037081" readonly="no"> |
| <descr> |
| <p>Meta information name. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-name-META" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="scheme" id="ID-35993789" readonly="no"> |
| <descr> |
| <p>Select form of content. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-scheme" form="simple" show="embed" actuate="auto">scheme attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLBaseElement" inherits="HTMLElement" id="ID-73629039"> |
| <descr> |
| <p>Document base URI. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#edef-BASE" form="simple" show="embed" actuate="auto">BASE element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="href" id="ID-65382887" readonly="no"> |
| <descr> |
| <p>The base URI See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-href-BASE" form="simple" show="embed" actuate="auto">href attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="target" id="ID-73844298" readonly="no"> |
| <descr> |
| <p>The default target frame. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-target" form="simple" show="embed" actuate="auto">target attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLIsIndexElement" inherits="HTMLElement" id="ID-85283003"> |
| <descr> |
| <p>This element is used for single-line text input. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-ISINDEX" form="simple" show="embed" actuate="auto">ISINDEX element definition</loc>in HTML 4.0. This element is deprecated in HTML 4.0.</p> |
| </descr> |
| <attribute readonly="yes" type="HTMLFormElement" name="form" id="ID-87069980"> |
| <descr> |
| <p>Returns the<code>FORM</code>element containing this control. Returns null if this control is not within the context of a form.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="prompt" id="ID-33589862" readonly="no"> |
| <descr> |
| <p>The prompt message. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-prompt" form="simple" show="embed" actuate="auto">prompt attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLStyleElement" inherits="HTMLElement" id="ID-16428977"> |
| <descr> |
| <p>Style information. A more detailed style sheet object model is planned to be defined in a separate document. See the<loc href="http://www.w3.org/TR/REC-html40/present/styles.html#edef-STYLE" form="simple" show="embed" actuate="auto">STYLE element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="boolean" name="disabled" id="ID-51162010" readonly="no"> |
| <descr> |
| <p>Enables/disables the style sheet.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="media" id="ID-76412738" readonly="no"> |
| <descr> |
| <p>Designed for use with one or more target media. See the<loc href="http://www.w3.org/TR/REC-html40/present/styles.html#adef-media" form="simple" show="embed" actuate="auto">media attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="type" id="ID-22472002" readonly="no"> |
| <descr> |
| <p>The style sheet language (Internet media type). See the<loc href="http://www.w3.org/TR/REC-html40/present/styles.html#adef-type-STYLE" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLBodyElement" inherits="HTMLElement" id="ID-62018039"> |
| <descr> |
| <p>The HTML document body. This element is always present in the DOM API, even if the tags are not present in the source document. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#edef-BODY" form="simple" show="embed" actuate="auto">BODY element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="aLink" id="ID-59424581" readonly="no"> |
| <descr> |
| <p>Color of active links (after mouse-button down, but before mouse-button up). See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-alink" form="simple" show="embed" actuate="auto">alink attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="background" id="ID-37574810" readonly="no"> |
| <descr> |
| <p>URI of the background texture tile image. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-background" form="simple" show="embed" actuate="auto">background attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="bgColor" id="ID-24940084" readonly="no"> |
| <descr> |
| <p>Document background color. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-bgcolor" form="simple" show="embed" actuate="auto">bgcolor attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="link" id="ID-7662206" readonly="no"> |
| <descr> |
| <p>Color of links that are not active and unvisited. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-link" form="simple" show="embed" actuate="auto">link attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="text" id="ID-73714763" readonly="no"> |
| <descr> |
| <p>Document text color. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-text" form="simple" show="embed" actuate="auto">text attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="vLink" id="ID-83224305" readonly="no"> |
| <descr> |
| <p>Color of links that have been visited by the user. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#adef-vlink" form="simple" show="embed" actuate="auto">vlink attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLFormElement" inherits="HTMLElement" id="ID-40002357"> |
| <descr> |
| <p>The<code>FORM</code>element encompasses behavior similar to a collection and an element. It provides direct access to the contained input elements as well as the attributes of the form element. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-FORM" form="simple" show="embed" actuate="auto">FORM element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute readonly="yes" type="HTMLCollection" name="elements" id="ID-76728479"> |
| <descr> |
| <p>Returns a collection of all control elements in the form.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="long" name="length"> |
| <descr> |
| <p>The number of form controls in the form.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-22051454" readonly="no"> |
| <descr> |
| <p>Names the form.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="acceptCharset" id="ID-19661795" readonly="no"> |
| <descr> |
| <p>List of character sets supported by the server. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-accept-charset" form="simple" show="embed" actuate="auto">accept-charset attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="action" id="ID-74049184" readonly="no"> |
| <descr> |
| <p>Server-side form handler. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-action" form="simple" show="embed" actuate="auto">action attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="enctype" id="ID-84227810" readonly="no"> |
| <descr> |
| <p>The content type of the submitted form, generally "application/x-www-form-urlencoded". See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-enctype" form="simple" show="embed" actuate="auto">enctype attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="method" id="ID-82545539" readonly="no"> |
| <descr> |
| <p>HTTP method used to submit form. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-method" form="simple" show="embed" actuate="auto">method attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="target" id="ID-6512890" readonly="no"> |
| <descr> |
| <p>Frame to render the resource in. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-target" form="simple" show="embed" actuate="auto">target attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <method name="submit" id="ID-76767676"> |
| <descr> |
| <p>Submits the form. It performs the same action as a submit button.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="reset" id="ID-76767677"> |
| <descr> |
| <p>Restores a form element's default values. It performs the same action as a reset button.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="HTMLSelectElement" inherits="HTMLElement" id="ID-94282980"> |
| <descr> |
| <p>The select element allows the selection of an option. The contained options can be directly accessed through the select element as a collection. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-SELECT" form="simple" show="embed" actuate="auto">SELECT element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute readonly="yes" type="DOMString" name="type" id="ID-58783172"> |
| <descr> |
| <p>The type of control created.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="selectedIndex" id="ID-85676760" readonly="no"> |
| <descr> |
| <p>The ordinal index of the selected option. The value -1 is returned if no element is selected. If multiple options are selected, the index of the first selected option is returned.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="value" id="ID-59351919" readonly="no"> |
| <descr> |
| <p>The current form control value.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="long" name="length" id="ID-5933486"> |
| <descr> |
| <p>The number of options in this<code>SELECT</code>.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLFormElement" name="form" id="ID-20489458"> |
| <descr> |
| <p>Returns the<code>FORM</code>element containing this control. Returns null if this control is not within the context of a form.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLCollection" name="options" id="ID-30606413"> |
| <descr> |
| <p>The collection of<code>OPTION</code>elements contained by this element.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="disabled" id="ID-79102918" readonly="no"> |
| <descr> |
| <p>The control is unavailable in this context. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-disabled" form="simple" show="embed" actuate="auto">disabled attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="multiple" id="ID-13246613" readonly="no"> |
| <descr> |
| <p>If true, multiple<code>OPTION</code>elements may be selected in this<code>SELECT</code>. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-multiple" form="simple" show="embed" actuate="auto">multiple attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-41636323" readonly="no"> |
| <descr> |
| <p>Form control or object name when submitted with a form. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-name-SELECT" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="size" id="ID-18293826" readonly="no"> |
| <descr> |
| <p>Number of visible rows. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-size-SELECT" form="simple" show="embed" actuate="auto">size attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="tabIndex" id="ID-40676705" readonly="no"> |
| <descr> |
| <p>Index that represents the element's position in the tabbing order. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-tabindex" form="simple" show="embed" actuate="auto">tabindex attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <method name="add" id="ID-14493106"> |
| <descr> |
| <p>Add a new element to the collection of<code>OPTION</code>elements for this<code>SELECT</code>.</p> |
| </descr> |
| <parameters> |
| <param id="ID-43168006" name="element" type="HTMLElement" attr="in"> |
| <descr> |
| <p>The element to add.</p> |
| </descr> |
| </param> |
| <param id="ID-76828919" name="before" type="HTMLElement" attr="in"> |
| <descr> |
| <p>The element to insert before, or NULL for the head of the list.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="remove" id="ID-33404570"> |
| <descr> |
| <p>Remove an element from the collection of<code>OPTION</code>elements for this<code>SELECT</code>. Does nothing if no element has the given index.</p> |
| </descr> |
| <parameters> |
| <param id="ID-36270997" name="index" type="long" attr="in"> |
| <descr> |
| <p>The index of the item to remove.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="blur" id="ID-28216144"> |
| <descr> |
| <p>Removes keyboard focus from this element.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="focus" id="ID-32130014"> |
| <descr> |
| <p>Gives keyboard focus to this element.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="HTMLOptGroupElement" inherits="HTMLElement" id="ID-38450247"> |
| <descr> |
| <p>Group options together in logical subdivisions. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-OPTGROUP" form="simple" show="embed" actuate="auto">OPTGROUP element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="boolean" name="disabled" id="ID-15518803" readonly="no"> |
| <descr> |
| <p>The control is unavailable in this context. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-disabled" form="simple" show="embed" actuate="auto">disabled attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="label" id="ID-95806054" readonly="no"> |
| <descr> |
| <p>Assigns a label to this option group. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-label-OPTGROUP" form="simple" show="embed" actuate="auto">label attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLOptionElement" inherits="HTMLElement" id="ID-70901257"> |
| <descr> |
| <p>A selectable choice. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-OPTION" form="simple" show="embed" actuate="auto">OPTION element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute readonly="yes" type="HTMLFormElement" name="form" id="ID-17116503"> |
| <descr> |
| <p>Returns the<code>FORM</code>element containing this control. Returns null if this control is not within the context of a form.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="defaultSelected" id="ID-37770574" readonly="no"> |
| <descr> |
| <p>Stores the initial value of the<code>selected</code>attribute.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="DOMString" name="text" id="ID-48154426"> |
| <descr> |
| <p>The text contained within the option element.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="index" id="ID-14038413" readonly="no"> |
| <descr> |
| <p>The index of this<code>OPTION</code>in its parent<code>SELECT</code>.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="disabled" id="ID-23482473" readonly="no"> |
| <descr> |
| <p>The control is unavailable in this context. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-disabled" form="simple" show="embed" actuate="auto">disabled attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="label" id="ID-40736115" readonly="no"> |
| <descr> |
| <p>Option label for use in hierarchical menus. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-label-OPTION" form="simple" show="embed" actuate="auto">label attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="boolean" name="selected" id="ID-70874476"> |
| <descr> |
| <p>Means that this option is initially selected. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-selected" form="simple" show="embed" actuate="auto">selected attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="value" id="ID-6185554" readonly="no"> |
| <descr> |
| <p>The current form control value. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-value-OPTION" form="simple" show="embed" actuate="auto">value attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLInputElement" inherits="HTMLElement" id="ID-6043025"> |
| <descr> |
| <p>Form control.<emph>Note.</emph>Depending upon the environment the page is being viewed, the value property may be read-only for the file upload input type. For the "password" input type, the actual value returned may be masked to prevent unauthorized use. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-INPUT" form="simple" show="embed" actuate="auto">INPUT element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="defaultValue" id="ID-26091157" readonly="no"> |
| <descr> |
| <p>Stores the initial control value (i.e., the initial value of<code>value</code>).</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="defaultChecked" id="ID-20509171" readonly="no"> |
| <descr> |
| <p>When<code>type</code>has the value "Radio" or "Checkbox", stores the initial value of the<code>checked</code>attribute.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLFormElement" name="form" id="ID-63239895"> |
| <descr> |
| <p>Returns the<code>FORM</code>element containing this control. Returns null if this control is not within the context of a form.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="accept" id="ID-15328520" readonly="no"> |
| <descr> |
| <p>A comma-separated list of content types that a server processing this form will handle correctly. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-accept" form="simple" show="embed" actuate="auto">accept attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="accessKey" id="ID-59914154" readonly="no"> |
| <descr> |
| <p>A single character access key to give access to the form control. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-accesskey" form="simple" show="embed" actuate="auto">accesskey attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="align" id="ID-96991182" readonly="no"> |
| <descr> |
| <p>Aligns this object (vertically or horizontally) with respect to its surrounding text. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-align-IMG" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="alt" id="ID-92701314" readonly="no"> |
| <descr> |
| <p>Alternate text for user agents not rendering the normal content of this element. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-alt" form="simple" show="embed" actuate="auto">alt attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="checked" id="ID-30233917" readonly="no"> |
| <descr> |
| <p>Describes whether a radio or check box is checked, when<code>type</code>has the value "Radio" or "Checkbox". The value is TRUE if explicitly set. Represents the current state of the checkbox or radio button. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-checked" form="simple" show="embed" actuate="auto">checked attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="disabled" id="ID-50886781" readonly="no"> |
| <descr> |
| <p>The control is unavailable in this context. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-disabled" form="simple" show="embed" actuate="auto">disabled attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="maxLength" id="ID-54719353" readonly="no"> |
| <descr> |
| <p>Maximum number of characters for text fields, when<code>type</code>has the value "Text" or "Password". See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-maxlength" form="simple" show="embed" actuate="auto">maxlength attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-89658498" readonly="no"> |
| <descr> |
| <p>Form control or object name when submitted with a form. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-name-INPUT" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="readOnly" id="ID-88461592" readonly="no"> |
| <descr> |
| <p>This control is read-only. When<code>type</code>has the value "text" or "password" only. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-readonly" form="simple" show="embed" actuate="auto">readonly attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="size" id="ID-79659438" readonly="no"> |
| <descr> |
| <p>Size information. The precise meaning is specific to each type of field. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-size-INPUT" form="simple" show="embed" actuate="auto">size attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="src" id="ID-97320704" readonly="no"> |
| <descr> |
| <p>When the<code>type</code>attribute has the value "Image", this attribute specifies the location of the image to be used to decorate the graphical submit button. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-src" form="simple" show="embed" actuate="auto">src attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="tabIndex" id="ID-62176355" readonly="no"> |
| <descr> |
| <p>Index that represents the element's position in the tabbing order. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-tabindex" form="simple" show="embed" actuate="auto">tabindex attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="DOMString" name="type" id="ID-62883744"> |
| <descr> |
| <p>The type of control created. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-type-INPUT" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="useMap" id="ID-32463706" readonly="no"> |
| <descr> |
| <p>Use client-side image map. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-usemap" form="simple" show="embed" actuate="auto">usemap attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="value" id="ID-49531485" readonly="no"> |
| <descr> |
| <p>The current form control value. Used for radio buttons and check boxes. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-value-INPUT" form="simple" show="embed" actuate="auto">value attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <method name="blur" id="ID-26838235"> |
| <descr> |
| <p>Removes keyboard focus from this element.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="focus" id="ID-65996295"> |
| <descr> |
| <p>Gives keyboard focus to this element.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="select" id="ID-34677168"> |
| <descr> |
| <p>Select the contents of the text area. For<code>INPUT</code>elements whose<code>type</code>attribute has one of the following values: "Text", "File", or "Password".</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="click" id="ID-2651361"> |
| <descr> |
| <p>Simulate a mouse-click. For<code>INPUT</code>elements whose<code>type</code>attribute has one of the following values: "Button", "Checkbox", "Radio", "Reset", or "Submit".</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="HTMLTextAreaElement" inherits="HTMLElement" id="ID-24874179"> |
| <descr> |
| <p>Multi-line text field. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-TEXTAREA" form="simple" show="embed" actuate="auto">TEXTAREA element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="defaultValue" id="ID-36152213" readonly="no"> |
| <descr> |
| <p>Stores the initial control value (i.e., the initial value of<code>value</code>).</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLFormElement" name="form" id="ID-18911464"> |
| <descr> |
| <p>Returns the<code>FORM</code>element containing this control. Returns null if this control is not within the context of a form.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="accessKey" id="ID-93102991" readonly="no"> |
| <descr> |
| <p>A single character access key to give access to the form control. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-accesskey" form="simple" show="embed" actuate="auto">accesskey attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="cols" id="ID-51387225" readonly="no"> |
| <descr> |
| <p>Width of control (in characters). See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-cols-TEXTAREA" form="simple" show="embed" actuate="auto">cols attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="disabled" id="ID-98725443" readonly="no"> |
| <descr> |
| <p>The control is unavailable in this context. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-disabled" form="simple" show="embed" actuate="auto">disabled attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-70715578" readonly="no"> |
| <descr> |
| <p>Form control or object name when submitted with a form. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-name-TEXTAREA" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="readOnly" id="ID-39131423" readonly="no"> |
| <descr> |
| <p>This control is read-only. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-readonly" form="simple" show="embed" actuate="auto">readonly attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="rows" id="ID-46975887" readonly="no"> |
| <descr> |
| <p>Number of text rows. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-rows-TEXTAREA" form="simple" show="embed" actuate="auto">rows attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="tabIndex" id="ID-60363303" readonly="no"> |
| <descr> |
| <p>Index that represents the element's position in the tabbing order. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-tabindex" form="simple" show="embed" actuate="auto">tabindex attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="DOMString" name="type"> |
| <descr> |
| <p>The type of this form control.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="value" id="ID-70715579" readonly="no"> |
| <descr> |
| <p>The current textual content of the multi-line text field. If the entirety of the data can not fit into a single wstring, the implementation may truncate the data.</p> |
| </descr> |
| </attribute> |
| <method name="blur" id="ID-6750689"> |
| <descr> |
| <p>Removes keyboard focus from this element.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="focus" id="ID-39055426"> |
| <descr> |
| <p>Gives keyboard focus to this element.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="select" id="ID-48880622"> |
| <descr> |
| <p>Select the contents of the<code>TEXTAREA</code>.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="HTMLButtonElement" inherits="HTMLElement" id="ID-34812697"> |
| <descr> |
| <p>Push button. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-BUTTON" form="simple" show="embed" actuate="auto">BUTTON element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute readonly="yes" type="HTMLFormElement" name="form" id="ID-71254493"> |
| <descr> |
| <p>Returns the<code>FORM</code>element containing this control. Returns null if this control is not within the context of a form.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="accessKey" id="ID-73169431" readonly="no"> |
| <descr> |
| <p>A single character access key to give access to the form control. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-accesskey" form="simple" show="embed" actuate="auto">accesskey attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="disabled" id="ID-92757155" readonly="no"> |
| <descr> |
| <p>The control is unavailable in this context. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-disabled" form="simple" show="embed" actuate="auto">disabled attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-11029910" readonly="no"> |
| <descr> |
| <p>Form control or object name when submitted with a form. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-name-BUTTON" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="tabIndex" id="ID-39190908" readonly="no"> |
| <descr> |
| <p>Index that represents the element's position in the tabbing order. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-tabindex" form="simple" show="embed" actuate="auto">tabindex attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="DOMString" name="type" id="ID-27430092"> |
| <descr> |
| <p>The type of button. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-type-BUTTON" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="value" id="ID-72856782" readonly="no"> |
| <descr> |
| <p>The current form control value. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-value-BUTTON" form="simple" show="embed" actuate="auto">value attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLLabelElement" inherits="HTMLElement" id="ID-13691394"> |
| <descr> |
| <p>Form field label text. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-LABEL" form="simple" show="embed" actuate="auto">LABEL element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute readonly="yes" type="HTMLFormElement" name="form" id="ID-32480901"> |
| <descr> |
| <p>Returns the<code>FORM</code>element containing this control. Returns null if this control is not within the context of a form.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="accessKey" id="ID-43589892" readonly="no"> |
| <descr> |
| <p>A single character access key to give access to the form control. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-accesskey" form="simple" show="embed" actuate="auto">accesskey attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="htmlFor" id="ID-96509813" readonly="no"> |
| <descr> |
| <p>This attribute links this label with another form control by<code>id</code>attribute. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-for" form="simple" show="embed" actuate="auto">for attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLFieldSetElement" inherits="HTMLElement" id="ID-7365882"> |
| <descr> |
| <p>Organizes form controls into logical groups. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-FIELDSET" form="simple" show="embed" actuate="auto">FIELDSET element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute readonly="yes" type="HTMLFormElement" name="form" id="ID-75392630"> |
| <descr> |
| <p>Returns the<code>FORM</code>element containing this control. Returns null if this control is not within the context of a form.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLLegendElement" inherits="HTMLElement" id="ID-21482039"> |
| <descr> |
| <p>Provides a captionfor a<code>FIELDSET</code>grouping. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#edef-LEGEND" form="simple" show="embed" actuate="auto">LEGEND element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute readonly="yes" type="HTMLFormElement" name="form" id="ID-29594519"> |
| <descr> |
| <p>Returns the<code>FORM</code>element containing this control. Returns null if this control is not within the context of a form.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="accessKey" id="ID-11297832" readonly="no"> |
| <descr> |
| <p>A single character access key to give access to the form control. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-accesskey" form="simple" show="embed" actuate="auto">accesskey attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="align" id="ID-79538067" readonly="no"> |
| <descr> |
| <p>Text alignment relative to<code>FIELDSET</code>. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-align-LEGEND" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLUListElement" inherits="HTMLElement" id="ID-86834457"> |
| <descr> |
| <p>Unordered list. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#edef-UL" form="simple" show="embed" actuate="auto">UL element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="boolean" name="compact" id="ID-39864178" readonly="no"> |
| <descr> |
| <p>Reduce spacing between list items. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#adef-compact" form="simple" show="embed" actuate="auto">compact attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="type" id="ID-96874670" readonly="no"> |
| <descr> |
| <p>Bullet style. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#adef-type-UL" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLOListElement" inherits="HTMLElement" id="ID-58056027"> |
| <descr> |
| <p>Ordered list. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#edef-OL" form="simple" show="embed" actuate="auto">OL element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="boolean" name="compact" id="ID-76448506" readonly="no"> |
| <descr> |
| <p>Reduce spacing between list items. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#adef-compact" form="simple" show="embed" actuate="auto">compact attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="start" id="ID-14793325" readonly="no"> |
| <descr> |
| <p>Starting sequence number. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#adef-start" form="simple" show="embed" actuate="auto">start attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="type" id="ID-40971103" readonly="no"> |
| <descr> |
| <p>Numbering style. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#adef-type-OL" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLDListElement" inherits="HTMLElement" id="ID-52368974"> |
| <descr> |
| <p>Definition list. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#edef-DL" form="simple" show="embed" actuate="auto">DL element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="boolean" name="compact" id="ID-21738539" readonly="no"> |
| <descr> |
| <p>Reduce spacing between list items. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#adef-compact" form="simple" show="embed" actuate="auto">compact attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLDirectoryElement" inherits="HTMLElement" id="ID-71600284"> |
| <descr> |
| <p>Directory list. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#edef-DIR" form="simple" show="embed" actuate="auto">DIR element definition</loc>in HTML 4.0. This element is deprecated in HTML 4.0.</p> |
| </descr> |
| <attribute type="boolean" name="compact" id="ID-75317739" readonly="no"> |
| <descr> |
| <p>Reduce spacing between list items. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#adef-compact" form="simple" show="embed" actuate="auto">compact attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLMenuElement" inherits="HTMLElement" id="ID-72509186"> |
| <descr> |
| <p>Menu list. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#edef-MENU" form="simple" show="embed" actuate="auto">MENU element definition</loc>in HTML 4.0. This element is deprecated in HTML 4.0.</p> |
| </descr> |
| <attribute type="boolean" name="compact" id="ID-68436464" readonly="no"> |
| <descr> |
| <p>Reduce spacing between list items. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#adef-compact" form="simple" show="embed" actuate="auto">compact attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLLIElement" inherits="HTMLElement" id="ID-74680021"> |
| <descr> |
| <p>List item. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#edef-LI" form="simple" show="embed" actuate="auto">LI element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="type" id="ID-52387668" readonly="no"> |
| <descr> |
| <p>List item bullet style. See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#adef-type-LI" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="value" id="ID-45496263" readonly="no"> |
| <descr> |
| <p>Reset sequence number when used in<code>OL</code>See the<loc href="http://www.w3.org/TR/REC-html40/struct/lists.html#adef-value-LI" form="simple" show="embed" actuate="auto">value attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLDivElement" inherits="HTMLElement" id="ID-22445964"> |
| <descr> |
| <p>Generic block container. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#edef-DIV" form="simple" show="embed" actuate="auto">DIV element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="align" id="ID-70908791" readonly="no"> |
| <descr> |
| <p>Horizontal text alignment. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-align" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLParagraphElement" inherits="HTMLElement" id="ID-84675076"> |
| <descr> |
| <p>Paragraphs. See the<loc href="http://www.w3.org/TR/REC-html40/struct/text.html#edef-P" form="simple" show="embed" actuate="auto">P element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="align" id="ID-53465507" readonly="no"> |
| <descr> |
| <p>Horizontal text alignment. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-align" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLHeadingElement" inherits="HTMLElement" id="ID-43345119"> |
| <descr> |
| <p>For the<code>H1</code>to<code>H6</code>elements. See the<loc href="http://www.w3.org/TR/REC-html40/struct/global.html#edef-H1" form="simple" show="embed" actuate="auto">H1 element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="align" id="ID-6796462" readonly="no"> |
| <descr> |
| <p>Horizontal text alignment. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-align" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLQuoteElement" inherits="HTMLElement" id="ID-70319763"> |
| <descr> |
| <p>For the<code>Q</code>and<code>BLOCKQUOTE</code>elements. See the<loc href="http://www.w3.org/TR/REC-html40/struct/text.html#edef-Q" form="simple" show="embed" actuate="auto">Q element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="cite" id="ID-53895598" readonly="no"> |
| <descr> |
| <p>A URI designating a document that designates a source document or message. See the<loc href="http://www.w3.org/TR/REC-html40/struct/text.html#adef-cite-Q" form="simple" show="embed" actuate="auto">cite attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLPreElement" inherits="HTMLElement" id="ID-11383425"> |
| <descr> |
| <p>Preformatted text. See the<loc href="http://www.w3.org/TR/REC-html40/struct/text.html#edef-PRE" form="simple" show="embed" actuate="auto">PRE element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="long" name="width" id="ID-13894083" readonly="no"> |
| <descr> |
| <p>Fixed width for content. See the<loc href="http://www.w3.org/TR/REC-html40/struct/text.html#adef-width-PRE" form="simple" show="embed" actuate="auto">width attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLBRElement" inherits="HTMLElement" id="ID-56836063"> |
| <descr> |
| <p>Force a line break. See the<loc href="http://www.w3.org/TR/REC-html40/struct/text.html#edef-BR" form="simple" show="embed" actuate="auto">BR element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="clear" id="ID-82703081" readonly="no"> |
| <descr> |
| <p>Control flow of text around floats. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-clear" form="simple" show="embed" actuate="auto">clear attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLBaseFontElement" inherits="HTMLElement" id="ID-32774408"> |
| <descr> |
| <p>Base font. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#edef-BASEFONT" form="simple" show="embed" actuate="auto">BASEFONT element definition</loc>in HTML 4.0. This element is deprecated in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="color" id="ID-87502302" readonly="no"> |
| <descr> |
| <p>Font color. See the<loc href="http://www.w3.org/TR/REC-html40/" form="simple" show="embed" actuate="auto">color attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="face" id="ID-88128969" readonly="no"> |
| <descr> |
| <p>Font face identifier. See the<loc href="http://www.w3.org/TR/REC-html40/" form="simple" show="embed" actuate="auto">face attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="size" id="ID-38930424" readonly="no"> |
| <descr> |
| <p>Font size. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-size-BASEFONT" form="simple" show="embed" actuate="auto">size attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLFontElement" inherits="HTMLElement" id="ID-43943847"> |
| <descr> |
| <p>Local change to font. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#edef-FONT" form="simple" show="embed" actuate="auto">FONT element definition</loc>in HTML 4.0. This element is deprecated in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="color" id="ID-53532975" readonly="no"> |
| <descr> |
| <p>Font color. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-color-FONT" form="simple" show="embed" actuate="auto">color attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="face" id="ID-55715655" readonly="no"> |
| <descr> |
| <p>Font face identifier. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-face-FONT" form="simple" show="embed" actuate="auto">face attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="size" id="ID-90127284" readonly="no"> |
| <descr> |
| <p>Font size. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-size-FONT" form="simple" show="embed" actuate="auto">size attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLHRElement" inherits="HTMLElement" id="ID-68228811"> |
| <descr> |
| <p>Create a horizontal rule. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#edef-HR" form="simple" show="embed" actuate="auto">HR element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="align" id="ID-15235012" readonly="no"> |
| <descr> |
| <p>Align the rule on the page. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-align-HR" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="noShade" id="ID-79813978" readonly="no"> |
| <descr> |
| <p>Indicates to the user agent that there should be no shading in the rendering of this element. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-noshade" form="simple" show="embed" actuate="auto">noshade attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="size" id="ID-77612587" readonly="no"> |
| <descr> |
| <p>The height of the rule. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-size-HR" form="simple" show="embed" actuate="auto">size attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="width" id="ID-87744198" readonly="no"> |
| <descr> |
| <p>The width of the rule. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-width-HR" form="simple" show="embed" actuate="auto">width attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLModElement" inherits="HTMLElement" id="ID-79359609"> |
| <descr> |
| <p>Notice of modification to part of a document. See the<loc href="http://www.w3.org/TR/REC-html40/struct/text.html#edef-ins" form="simple" show="embed" actuate="auto">INS</loc>and<loc href="http://www.w3.org/TR/REC-html40/struct/text.html#edef-del" form="simple" show="embed" actuate="auto">DEL</loc>element definitions in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="cite" id="ID-75101708" readonly="no"> |
| <descr> |
| <p>A URI designating a document that describes the reason for the change. See the<loc href="http://www.w3.org/TR/REC-html40/" form="simple" show="embed" actuate="auto">cite attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="dateTime" id="ID-88432678" readonly="no"> |
| <descr> |
| <p>The date and time of the change. See the<loc href="http://www.w3.org/TR/REC-html40/struct/text.html#adef-datetime" form="simple" show="embed" actuate="auto">datetime attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLAnchorElement" inherits="HTMLElement" id="ID-48250443"> |
| <descr> |
| <p>The anchor element. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#edef-A" form="simple" show="embed" actuate="auto">A element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="accessKey" id="ID-89647724" readonly="no"> |
| <descr> |
| <p>A single character access key to give access to the form control. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-accesskey" form="simple" show="embed" actuate="auto">accesskey attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="charset" id="ID-67619266" readonly="no"> |
| <descr> |
| <p>The character encoding of the linked resource. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-charset" form="simple" show="embed" actuate="auto">charset attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="coords" id="ID-92079539" readonly="no"> |
| <descr> |
| <p>Comma-separated list of lengths, defining an active region geometry. See also<code>shape</code>for the shape of the region. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-coords" form="simple" show="embed" actuate="auto">coords attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="href" id="ID-88517319" readonly="no"> |
| <descr> |
| <p>The URI of the linked resource. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-href" form="simple" show="embed" actuate="auto">href attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="hreflang" id="ID-87358513" readonly="no"> |
| <descr> |
| <p>Language code of the linked resource. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-hreflang" form="simple" show="embed" actuate="auto">hreflang attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-32783304" readonly="no"> |
| <descr> |
| <p>Anchor name. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-name-A" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="rel" id="ID-3815891" readonly="no"> |
| <descr> |
| <p>Forward link type. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-rel" form="simple" show="embed" actuate="auto">rel attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="rev" id="ID-58259771" readonly="no"> |
| <descr> |
| <p>Reverse link type. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-rev" form="simple" show="embed" actuate="auto">rev attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="shape" id="ID-49899808" readonly="no"> |
| <descr> |
| <p>The shape of the active area. The coordinates are given by<code>coords</code>. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-shape" form="simple" show="embed" actuate="auto">shape attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="tabIndex" id="ID-41586466" readonly="no"> |
| <descr> |
| <p>Index that represents the element's position in the tabbing order. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-tabindex" form="simple" show="embed" actuate="auto">tabindex attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="target" id="ID-6414197" readonly="no"> |
| <descr> |
| <p>Frame to render the resource in. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-target" form="simple" show="embed" actuate="auto">target attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="type" id="ID-63938221" readonly="no"> |
| <descr> |
| <p>Advisory content type. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-type-A" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <method name="blur" id="ID-65068939"> |
| <descr> |
| <p>Removes keyboard focus from this element.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="focus" id="ID-47150313"> |
| <descr> |
| <p>Gives keyboard focus to this element.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="HTMLImageElement" inherits="HTMLElement" id="ID-17701901"> |
| <descr> |
| <p>Embedded image. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#edef-IMG" form="simple" show="embed" actuate="auto">IMG element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="lowSrc" id="ID-91256910" readonly="no"> |
| <descr> |
| <p>URI designating the source of this image, for low-resolution output.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-47534097" readonly="no"> |
| <descr> |
| <p>The name of the element (for backwards compatibility).</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="align" id="ID-3211094" readonly="no"> |
| <descr> |
| <p>Aligns this object (vertically or horizontally) with respect to its surrounding text. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-align-IMG" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="alt" id="ID-95636861" readonly="no"> |
| <descr> |
| <p>Alternate text for user agents not rendering the normal content of this element. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-alt" form="simple" show="embed" actuate="auto">alt attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="border" id="ID-136671" readonly="no"> |
| <descr> |
| <p>Width of border around image. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-border-IMG" form="simple" show="embed" actuate="auto">border attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="height" id="ID-91561496" readonly="no"> |
| <descr> |
| <p>Override height. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-height-IMG" form="simple" show="embed" actuate="auto">height attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="hspace" id="ID-53675471" readonly="no"> |
| <descr> |
| <p>Horizontal space to the left and right of this image. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-hspace" form="simple" show="embed" actuate="auto">hspace attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="isMap" id="ID-58983880" readonly="no"> |
| <descr> |
| <p>Use server-side image map. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-ismap" form="simple" show="embed" actuate="auto">ismap attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="longDesc" id="ID-77376969" readonly="no"> |
| <descr> |
| <p>URI designating a long description of this image or frame. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-longdesc-IMG" form="simple" show="embed" actuate="auto">longdesc attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="src" id="ID-87762984" readonly="no"> |
| <descr> |
| <p>URI designating the source of this image. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-src-IMG" form="simple" show="embed" actuate="auto">src attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="useMap" id="ID-35981181" readonly="no"> |
| <descr> |
| <p>Use client-side image map. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-usemap" form="simple" show="embed" actuate="auto">usemap attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="vspace" id="ID-85374897" readonly="no"> |
| <descr> |
| <p>Vertical space above and below this image. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-vspace" form="simple" show="embed" actuate="auto">vspace attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="width" id="ID-13839076" readonly="no"> |
| <descr> |
| <p>Override width. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-width-IMG" form="simple" show="embed" actuate="auto">width attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLObjectElement" inherits="HTMLElement" id="ID-9893177"> |
| <descr> |
| <p>Generic embedded object.<emph>Note.</emph>In principle, all properties on the object element are read-write but in some environments some properties may be read-only once the underlying object is instantiated. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#edef-OBJECT" form="simple" show="embed" actuate="auto">OBJECT element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute readonly="yes" type="HTMLFormElement" name="form" id="ID-46094773"> |
| <descr> |
| <p>Returns the<code>FORM</code>element containing this control. Returns null if this control is not within the context of a form.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="code" id="ID-75241146" readonly="no"> |
| <descr> |
| <p>Applet class file. See the<code>code</code>attribute for HTMLAppletElement.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="align" id="ID-16962097" readonly="no"> |
| <descr> |
| <p>Aligns this object (vertically or horizontally) with respect to its surrounding text. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-align-IMG" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="archive" id="ID-47783837" readonly="no"> |
| <descr> |
| <p>Space-separated list of archives. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-archive-OBJECT" form="simple" show="embed" actuate="auto">archive attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="border" id="ID-82818419" readonly="no"> |
| <descr> |
| <p>Width of border around the object. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-border" form="simple" show="embed" actuate="auto">border attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="codeBase" id="ID-25709136" readonly="no"> |
| <descr> |
| <p>Base URI for<code>classid</code>,<code>data</code>, and<code>archive</code>attributes. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-codebase-OBJECT" form="simple" show="embed" actuate="auto">codebase attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="codeType" id="ID-19945008" readonly="no"> |
| <descr> |
| <p>Content type for data downloaded via<code>classid</code>attribute. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-codetype" form="simple" show="embed" actuate="auto">codetype attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="data" id="ID-81766986" readonly="no"> |
| <descr> |
| <p>A URI specifying the location of the object's data. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-data" form="simple" show="embed" actuate="auto">data attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="declare" id="ID-942770" readonly="no"> |
| <descr> |
| <p>Declare (for future reference), but do not instantiate, this object. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-declare" form="simple" show="embed" actuate="auto">declare attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="height" id="ID-88925838" readonly="no"> |
| <descr> |
| <p>Override height. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-height-IMG" form="simple" show="embed" actuate="auto">height attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="hspace" id="ID-17085376" readonly="no"> |
| <descr> |
| <p>Horizontal space to the left and right of this image, applet, or object. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-hspace" form="simple" show="embed" actuate="auto">hspace attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-20110362" readonly="no"> |
| <descr> |
| <p>Form control or object name when submitted with a form. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-name-INPUT" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="standby" id="ID-25039673" readonly="no"> |
| <descr> |
| <p>Message to render while loading the object. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-standby" form="simple" show="embed" actuate="auto">standby attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="tabIndex" id="ID-27083787" readonly="no"> |
| <descr> |
| <p>Index that represents the element's position in the tabbing order. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-tabindex" form="simple" show="embed" actuate="auto">tabindex attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="type" id="ID-91665621" readonly="no"> |
| <descr> |
| <p>Content type for data downloaded via<code>data</code>attribute. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-type-OBJECT" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="useMap" id="ID-6649772" readonly="no"> |
| <descr> |
| <p>Use client-side image map. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-usemap" form="simple" show="embed" actuate="auto">usemap attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="vspace" id="ID-8682483" readonly="no"> |
| <descr> |
| <p>Vertical space above and below this image, applet, or object. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-vspace" form="simple" show="embed" actuate="auto">vspace attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="width" id="ID-38538620" readonly="no"> |
| <descr> |
| <p>Override width. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-width-IMG" form="simple" show="embed" actuate="auto">width attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLParamElement" inherits="HTMLElement" id="ID-64077273"> |
| <descr> |
| <p>Parameters fed to the<code>OBJECT</code>element. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#edef-PARAM" form="simple" show="embed" actuate="auto">PARAM element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="name" id="ID-59871447" readonly="no"> |
| <descr> |
| <p>The name of a run-time parameter. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-name-PARAM" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="type" id="ID-18179888" readonly="no"> |
| <descr> |
| <p>Content type for the<code>value</code>attribute when<code>valuetype</code>has the value "ref". See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-type-PARAM" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="value" id="ID-77971357" readonly="no"> |
| <descr> |
| <p>The value of a run-time parameter. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-value-PARAM" form="simple" show="embed" actuate="auto">value attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="valueType" id="ID-23931872" readonly="no"> |
| <descr> |
| <p>Information about the meaning of the<code>value</code>attribute value. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-valuetype" form="simple" show="embed" actuate="auto">valuetype attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLAppletElement" inherits="HTMLElement" id="ID-31006348"> |
| <descr> |
| <p>An embedded Java applet. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#edef-APPLET" form="simple" show="embed" actuate="auto">APPLET element definition</loc>in HTML 4.0. This element is deprecated in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="align" id="ID-8049912" readonly="no"> |
| <descr> |
| <p>Aligns this object (vertically or horizontally) with respect to its surrounding text. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-align-IMG" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="alt" id="ID-58610064" readonly="no"> |
| <descr> |
| <p>Alternate text for user agents not rendering the normal content of this element. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-alt" form="simple" show="embed" actuate="auto">alt attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="archive" id="ID-14476360" readonly="no"> |
| <descr> |
| <p>Comma-separated archive list. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-archive-APPLET" form="simple" show="embed" actuate="auto">archive attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="code" id="ID-61509645" readonly="no"> |
| <descr> |
| <p>Applet class file. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-code" form="simple" show="embed" actuate="auto">code attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="codeBase" id="ID-6581160" readonly="no"> |
| <descr> |
| <p>Optional base URI for applet. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-codebase-APPLET" form="simple" show="embed" actuate="auto">codebase attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="height" id="ID-90184867" readonly="no"> |
| <descr> |
| <p>Override height. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-height-APPLET" form="simple" show="embed" actuate="auto">height attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="hspace" id="ID-1567197" readonly="no"> |
| <descr> |
| <p>Horizontal space to the left and right of this image, applet, or object. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-hspace" form="simple" show="embed" actuate="auto">hspace attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-39843695" readonly="no"> |
| <descr> |
| <p>The name of the applet. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-name-APPLET" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="object" id="ID-93681523" readonly="no"> |
| <descr> |
| <p>Serialized applet file. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-object" form="simple" show="embed" actuate="auto">object attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="vspace" id="ID-22637173" readonly="no"> |
| <descr> |
| <p>Vertical space above and below this image, applet, or object. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-vspace" form="simple" show="embed" actuate="auto">vspace attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="width" id="ID-16526327" readonly="no"> |
| <descr> |
| <p>Override width. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-width-APPLET" form="simple" show="embed" actuate="auto">width attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLMapElement" inherits="HTMLElement" id="ID-94109203"> |
| <descr> |
| <p>Client-side image map. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#edef-MAP" form="simple" show="embed" actuate="auto">MAP element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute readonly="yes" type="HTMLCollection" name="areas" id="ID-71838730"> |
| <descr> |
| <p>The list of areas defined for the image map.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-52696514" readonly="no"> |
| <descr> |
| <p>Names the map (for use with<code>usemap</code>). See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-name-MAP" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLAreaElement" inherits="HTMLElement" id="ID-26019118"> |
| <descr> |
| <p>Client-side image map area definition. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#edef-AREA" form="simple" show="embed" actuate="auto">AREA element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="accessKey" id="ID-57944457" readonly="no"> |
| <descr> |
| <p>A single character access key to give access to the form control. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-accesskey" form="simple" show="embed" actuate="auto">accesskey attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="alt" id="ID-39775416" readonly="no"> |
| <descr> |
| <p>Alternate text for user agents not rendering the normal content of this element. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-alt" form="simple" show="embed" actuate="auto">alt attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="coords" id="ID-66021476" readonly="no"> |
| <descr> |
| <p>Comma-separated list of lengths, defining an active region geometry. See also<code>shape</code>for the shape of the region. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-coords" form="simple" show="embed" actuate="auto">coords attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="href" id="ID-34672936" readonly="no"> |
| <descr> |
| <p>The URI of the linked resource. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-href" form="simple" show="embed" actuate="auto">href attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="noHref" id="ID-61826871" readonly="no"> |
| <descr> |
| <p>Specifies that this area is inactive, i.e., has no associated action. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-nohref" form="simple" show="embed" actuate="auto">nohref attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="shape" id="ID-85683271" readonly="no"> |
| <descr> |
| <p>The shape of the active area. The coordinates are given by<code>coords</code>. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-shape" form="simple" show="embed" actuate="auto">shape attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="tabIndex" id="ID-8722121" readonly="no"> |
| <descr> |
| <p>Index that represents the element's position in the tabbing order. See the<loc href="http://www.w3.org/TR/REC-html40/interact/forms.html#adef-tabindex" form="simple" show="embed" actuate="auto">tabindex attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="target" id="ID-46054682" readonly="no"> |
| <descr> |
| <p>Frame to render the resource in. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-target" form="simple" show="embed" actuate="auto">target attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLScriptElement" inherits="HTMLElement" id="ID-81598695"> |
| <descr> |
| <p>Script statements. See the<loc href="http://www.w3.org/TR/REC-html40/interact/scripts.html#edef-SCRIPT" form="simple" show="embed" actuate="auto">SCRIPT element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="text" id="ID-46872999" readonly="no"> |
| <descr> |
| <p>The script content of the element.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="htmlFor" id="ID-66979266" readonly="no"> |
| <descr> |
| <p> |
| <emph>Reserved for future use.</emph> |
| </p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="event" id="ID-56700403" readonly="no"> |
| <descr> |
| <p> |
| <emph>Reserved for future use.</emph> |
| </p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="charset" id="ID-35305677" readonly="no"> |
| <descr> |
| <p>The character encoding of the linked resource. See the<loc href="http://www.w3.org/TR/REC-html40/struct/links.html#adef-charset" form="simple" show="embed" actuate="auto">charset attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="defer" id="ID-93788534" readonly="no"> |
| <descr> |
| <p>Indicates that the user agent can defer processing of the script. See the<loc href="http://www.w3.org/TR/REC-html40/interact/scripts.html#adef-defer" form="simple" show="embed" actuate="auto">defer attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="src" id="ID-75147231" readonly="no"> |
| <descr> |
| <p>URI designating an external script. See the<loc href="http://www.w3.org/TR/REC-html40/interact/scripts.html#adef-src-SCRIPT" form="simple" show="embed" actuate="auto">src attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="type" id="ID-30534818" readonly="no"> |
| <descr> |
| <p>The content type of the script language. See the<loc href="http://www.w3.org/TR/REC-html40/interact/scripts.html#adef-type-SCRIPT" form="simple" show="embed" actuate="auto">type attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLTableElement" inherits="HTMLElement" id="ID-64060425"> |
| <descr> |
| <p>The create* and delete* methods on the table allow authors to construct and modify tables. HTML 4.0 specifies that only one of each of the<code>CAPTION</code>,<code>THEAD</code>, and<code>TFOOT</code>elements may exist in a table. Therefore, if one exists, and the createTHead() or createTFoot() method is called, the method returns the existing THead or TFoot element. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#edef-TABLE" form="simple" show="embed" actuate="auto">TABLE element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="HTMLTableCaptionElement" name="caption" id="ID-14594520" readonly="no"> |
| <descr> |
| <p>Returns the table's<code>CAPTION</code>, or void if none exists.</p> |
| </descr> |
| </attribute> |
| <attribute type="HTMLTableSectionElement" name="tHead" id="ID-9530944" readonly="no"> |
| <descr> |
| <p>Returns the table's<code>THEAD</code>, or<code>null</code>if none exists.</p> |
| </descr> |
| </attribute> |
| <attribute type="HTMLTableSectionElement" name="tFoot" id="ID-64197097" readonly="no"> |
| <descr> |
| <p>Returns the table's<code>TFOOT</code>, or<code>null</code>if none exists.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLCollection" name="rows" id="ID-6156016"> |
| <descr> |
| <p>Returns a collection of all the rows in the table, including all in<code>THEAD</code>,<code>TFOOT</code>, all<code>TBODY</code>elements.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLCollection" name="tBodies" id="ID-63206416"> |
| <descr> |
| <p>Returns a collection of the defined table bodies.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="align" id="ID-23180977" readonly="no"> |
| <descr> |
| <p>Specifies the table's position with respect to the rest of the document. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-align-TABLE" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="bgColor" id="ID-83532985" readonly="no"> |
| <descr> |
| <p>Cell background color. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-bgcolor" form="simple" show="embed" actuate="auto">bgcolor attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="border" id="ID-50969400" readonly="no"> |
| <descr> |
| <p>The width of the border around the table. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-border-TABLE" form="simple" show="embed" actuate="auto">border attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="cellPadding" id="ID-59162158" readonly="no"> |
| <descr> |
| <p>Specifies the horizontal and vertical space between cell content and cell borders. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-cellpadding" form="simple" show="embed" actuate="auto">cellpadding attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="cellSpacing" id="ID-68907883" readonly="no"> |
| <descr> |
| <p>Specifies the horizontal and vertical separation between cells. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-cellspacing" form="simple" show="embed" actuate="auto">cellspacing attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="frame" id="ID-64808476" readonly="no"> |
| <descr> |
| <p>Specifies which external table borders to render. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-frame" form="simple" show="embed" actuate="auto">frame attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="rules" id="ID-26347553" readonly="no"> |
| <descr> |
| <p>Specifies which internal table borders to render. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-rules" form="simple" show="embed" actuate="auto">rules attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="summary" id="ID-44998528" readonly="no"> |
| <descr> |
| <p>Supplementary description about the purpose or structure of a table. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-summary" form="simple" show="embed" actuate="auto">summary attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="width" id="ID-77447361" readonly="no"> |
| <descr> |
| <p>Specifies the desired table width. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-width-TABLE" form="simple" show="embed" actuate="auto">width attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <method name="createTHead" id="ID-70313345"> |
| <descr> |
| <p>Create a table header row or return an existing one.</p> |
| </descr> |
| <parameters/> |
| <returns type="HTMLElement"> |
| <descr> |
| <p>A new table header element (<code>THEAD</code>).</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="deleteTHead" id="ID-38310198"> |
| <descr> |
| <p>Delete the header from the table, if one exists.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="createTFoot" id="ID-8453710"> |
| <descr> |
| <p>Create a table footer row or return an existing one.</p> |
| </descr> |
| <parameters/> |
| <returns type="HTMLElement"> |
| <descr> |
| <p>A footer element (<code>TFOOT</code>).</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="deleteTFoot" id="ID-78363258"> |
| <descr> |
| <p>Delete the footer from the table, if one exists.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="createCaption" id="ID-96920263"> |
| <descr> |
| <p>Create a new table caption object or return an existing one.</p> |
| </descr> |
| <parameters/> |
| <returns type="HTMLElement"> |
| <descr> |
| <p>A<code>CAPTION</code>element.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="deleteCaption" id="ID-22930071"> |
| <descr> |
| <p>Delete the table caption, if one exists.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="insertRow" id="ID-39872903"> |
| <descr> |
| <p>Insert a new empty row in the table.<emph>Note.</emph>A table row cannot be empty according to HTML 4.0 Recommendation.</p> |
| </descr> |
| <parameters> |
| <param id="ID-3501423" name="index" type="long" attr="in"> |
| <descr> |
| <p>The row number where to insert a new row.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="HTMLElement"> |
| <descr> |
| <p>The newly created row.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="deleteRow" id="ID-13114938"> |
| <descr> |
| <p>Delete a table row.</p> |
| </descr> |
| <parameters> |
| <param id="ID-41440100" name="index" type="long" attr="in"> |
| <descr> |
| <p>The index of the row to be deleted.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="HTMLTableCaptionElement" inherits="HTMLElement" id="ID-12035137"> |
| <descr> |
| <p>Table caption See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#edef-CAPTION" form="simple" show="embed" actuate="auto">CAPTION element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="align" id="ID-79875068" readonly="no"> |
| <descr> |
| <p>Caption alignment with respect to the table. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-align-CAPTION" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLTableColElement" inherits="HTMLElement" id="ID-84150186"> |
| <descr> |
| <p>Regroups the<code>COL</code>and<code>COLGROUP</code>elements. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#edef-COL" form="simple" show="embed" actuate="auto">COL element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="align" id="ID-31128447" readonly="no"> |
| <descr> |
| <p>Horizontal alignment of cell data in column. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-align-TD" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="ch" id="ID-9447412" readonly="no"> |
| <descr> |
| <p>Alignment character for cells in a column. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-char" form="simple" show="embed" actuate="auto">char attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="chOff" id="ID-57779225" readonly="no"> |
| <descr> |
| <p>Offset of alignment character. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-charoff" form="simple" show="embed" actuate="auto">charoff attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="span" id="ID-96511335" readonly="no"> |
| <descr> |
| <p>Indicates the number of columns in a group or affected by a grouping. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-span-COL" form="simple" show="embed" actuate="auto">span attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="vAlign" id="ID-83291710" readonly="no"> |
| <descr> |
| <p>Vertical alignment of cell data in column. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-valign" form="simple" show="embed" actuate="auto">valign attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="width" id="ID-25196799" readonly="no"> |
| <descr> |
| <p>Default column width. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-width-COL" form="simple" show="embed" actuate="auto">width attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLTableSectionElement" inherits="HTMLElement" id="ID-67417573"> |
| <descr> |
| <p>The<code>THEAD</code>,<code>TFOOT</code>, and<code>TBODY</code>elements.</p> |
| </descr> |
| <attribute type="DOMString" name="align" id="ID-40530119" readonly="no"> |
| <descr> |
| <p>Horizontal alignment of data in cells. See the<code>align</code>attribute for HTMLTheadElement for details.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="ch" id="ID-83470012" readonly="no"> |
| <descr> |
| <p>Alignment character for cells in a column. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-char" form="simple" show="embed" actuate="auto">char attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="chOff" id="ID-53459732" readonly="no"> |
| <descr> |
| <p>Offset of alignment character. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-charoff" form="simple" show="embed" actuate="auto">charoff attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="vAlign" id="ID-4379116" readonly="no"> |
| <descr> |
| <p>Vertical alignment of data in cells. See the<code>valign</code>attribute for HTMLTheadElement for details.</p> |
| </descr> |
| </attribute> |
| <attribute readonly="yes" type="HTMLCollection" name="rows" id="ID-52092650"> |
| <descr> |
| <p>The collection of rows in this table section.</p> |
| </descr> |
| </attribute> |
| <method name="insertRow" id="ID-93995626"> |
| <descr> |
| <p>Insert a row into this section.</p> |
| </descr> |
| <parameters> |
| <param id="ID-48322963" name="index" type="long" attr="in"> |
| <descr> |
| <p>The row number where to insert a new row.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="HTMLElement"> |
| <descr> |
| <p>The newly created row.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="deleteRow" id="ID-5625626"> |
| <descr> |
| <p>Delete a row from this section.</p> |
| </descr> |
| <parameters> |
| <param id="ID-49711281" name="index" type="long" attr="in"> |
| <descr> |
| <p>The index of the row to be deleted.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="HTMLTableRowElement" inherits="HTMLElement" id="ID-6986576"> |
| <descr> |
| <p>A row in a table. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#edef-TR" form="simple" show="embed" actuate="auto">TR element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="long" name="rowIndex" id="ID-67347567" readonly="no"> |
| <descr> |
| <p>The index of this row, relative to the entire table.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="sectionRowIndex" id="ID-79105901" readonly="no"> |
| <descr> |
| <p>The index of this row, relative to the current section (<code>THEAD</code>,<code>TFOOT</code>, or<code>TBODY</code>).</p> |
| </descr> |
| </attribute> |
| <attribute type="HTMLCollection" name="cells" id="ID-67349879" readonly="no"> |
| <descr> |
| <p>The collection of cells in this row.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="align" id="ID-74098257" readonly="no"> |
| <descr> |
| <p>Horizontal alignment of data within cells of this row. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-align-TD" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="bgColor" id="ID-18161327" readonly="no"> |
| <descr> |
| <p>Background color for rows. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-bgcolor" form="simple" show="embed" actuate="auto">bgcolor attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="ch" id="ID-16230502" readonly="no"> |
| <descr> |
| <p>Alignment character for cells in a column. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-char" form="simple" show="embed" actuate="auto">char attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="chOff" id="ID-68207461" readonly="no"> |
| <descr> |
| <p>Offset of alignment character. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-charoff" form="simple" show="embed" actuate="auto">charoff attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="vAlign" id="ID-90000058" readonly="no"> |
| <descr> |
| <p>Vertical alignment of data within cells of this row. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-valign" form="simple" show="embed" actuate="auto">valign attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <method name="insertCell" id="ID-68927016"> |
| <descr> |
| <p>Insert an empty<code>TD</code>cell into this row.</p> |
| </descr> |
| <parameters> |
| <param id="ID-20576436" name="index" type="long" attr="in"> |
| <descr> |
| <p>The place to insert the cell.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="HTMLElement"> |
| <descr> |
| <p>The newly created cell.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="deleteCell" id="ID-11738598"> |
| <descr> |
| <p>Delete a cell from the current row.</p> |
| </descr> |
| <parameters> |
| <param id="ID-63209996" name="index" type="long" attr="in"> |
| <descr> |
| <p>The index of the cell to delete.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="HTMLTableCellElement" inherits="HTMLElement" id="ID-82915075"> |
| <descr> |
| <p>The object used to represent the<code>TH</code>and<code>TD</code>elements. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#edef-TD" form="simple" show="embed" actuate="auto">TD element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="long" name="cellIndex" id="ID-80748363" readonly="no"> |
| <descr> |
| <p>The index of this cell in the row.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="abbr" id="ID-74444037" readonly="no"> |
| <descr> |
| <p>Abbreviation for header cells. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-abbr" form="simple" show="embed" actuate="auto">abbr attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="align" id="ID-98433879" readonly="no"> |
| <descr> |
| <p>Horizontal alignment of data in cell. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-align-TD" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="axis" id="ID-76554418" readonly="no"> |
| <descr> |
| <p>Names group of related headers. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-axis" form="simple" show="embed" actuate="auto">axis attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="bgColor" id="ID-88135431" readonly="no"> |
| <descr> |
| <p>Cell background color. See the<loc href="http://www.w3.org/TR/REC-html40/present/graphics.html#adef-bgcolor" form="simple" show="embed" actuate="auto">bgcolor attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="ch" id="ID-30914780" readonly="no"> |
| <descr> |
| <p>Alignment character for cells in a column. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-char" form="simple" show="embed" actuate="auto">char attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="chOff" id="ID-20144310" readonly="no"> |
| <descr> |
| <p>Offset of alignment character. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-charoff" form="simple" show="embed" actuate="auto">charoff attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="colSpan" id="ID-84645244" readonly="no"> |
| <descr> |
| <p>Number of columns spanned by cell. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-colspan" form="simple" show="embed" actuate="auto">colspan attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="headers" id="ID-89104817" readonly="no"> |
| <descr> |
| <p>List of<code>id</code>attribute values for header cells. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-headers" form="simple" show="embed" actuate="auto">headers attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="height" id="ID-83679212" readonly="no"> |
| <descr> |
| <p>Cell height. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-height-TH" form="simple" show="embed" actuate="auto">height attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="noWrap" id="ID-62922045" readonly="no"> |
| <descr> |
| <p>Suppress word wrapping. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-nowrap" form="simple" show="embed" actuate="auto">nowrap attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="rowSpan" id="ID-48237625" readonly="no"> |
| <descr> |
| <p>Number of rows spanned by cell. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-rowspan" form="simple" show="embed" actuate="auto">rowspan attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="scope" id="ID-36139952" readonly="no"> |
| <descr> |
| <p>Scope covered by header cells. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-scope" form="simple" show="embed" actuate="auto">scope attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="vAlign" id="ID-58284221" readonly="no"> |
| <descr> |
| <p>Vertical alignment of data in cell. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-valign" form="simple" show="embed" actuate="auto">valign attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="width" id="ID-27480795" readonly="no"> |
| <descr> |
| <p>Cell width. See the<loc href="http://www.w3.org/TR/REC-html40/struct/tables.html#adef-width-TH" form="simple" show="embed" actuate="auto">width attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLFrameSetElement" inherits="HTMLElement" id="ID-43829095"> |
| <descr> |
| <p>Create a grid of frames. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#edef-FRAMESET" form="simple" show="embed" actuate="auto">FRAMESET element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="cols" id="ID-98869594" readonly="no"> |
| <descr> |
| <p>The number of columns of frames in the frameset. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-cols-FRAMESET" form="simple" show="embed" actuate="auto">cols attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="rows" id="ID-19739247" readonly="no"> |
| <descr> |
| <p>The number of rows of frames in the frameset. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-rows-FRAMESET" form="simple" show="embed" actuate="auto">rows attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLFrameElement" inherits="HTMLElement" id="ID-97790553"> |
| <descr> |
| <p>Create a frame. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#edef-FRAME" form="simple" show="embed" actuate="auto">FRAME element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="frameBorder" id="ID-11858633" readonly="no"> |
| <descr> |
| <p>Request frame borders. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-frameborder" form="simple" show="embed" actuate="auto">frameborder attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="longDesc" id="ID-7836998" readonly="no"> |
| <descr> |
| <p>URI designating a long description of this image or frame. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-longdesc-FRAME" form="simple" show="embed" actuate="auto">longdesc attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="marginHeight" id="ID-55569778" readonly="no"> |
| <descr> |
| <p>Frame margin height, in pixels. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-marginheight" form="simple" show="embed" actuate="auto">marginheight attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="marginWidth" id="ID-8369969" readonly="no"> |
| <descr> |
| <p>Frame margin width, in pixels. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-marginwidth" form="simple" show="embed" actuate="auto">marginwidth attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-91128709" readonly="no"> |
| <descr> |
| <p>The frame name (object of the<code>target</code>attribute). See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-name-FRAME" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="noResize" id="ID-80766578" readonly="no"> |
| <descr> |
| <p>When true, forbid user from resizing frame. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-noresize" form="simple" show="embed" actuate="auto">noresize attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="scrolling" id="ID-45411424" readonly="no"> |
| <descr> |
| <p>Specify whether or not the frame should have scrollbars. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-scrolling" form="simple" show="embed" actuate="auto">scrolling attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="src" id="ID-78799535" readonly="no"> |
| <descr> |
| <p>A URI designating the initial frame contents. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-src-FRAME" form="simple" show="embed" actuate="auto">src attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| <interface name="HTMLIFrameElement" inherits="HTMLElement" id="ID-50708718"> |
| <descr> |
| <p>Inline subwindows. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#edef-IFRAME" form="simple" show="embed" actuate="auto">IFRAME element definition</loc>in HTML 4.0.</p> |
| </descr> |
| <attribute type="DOMString" name="align" id="ID-11309947" readonly="no"> |
| <descr> |
| <p>Aligns this object (vertically or horizontally) with respect to its surrounding text. See the<loc href="http://www.w3.org/TR/REC-html40/struct/objects.html#adef-align-IMG" form="simple" show="embed" actuate="auto">align attribute definition</loc>in HTML 4.0. This attribute is deprecated in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="frameBorder" id="ID-22463410" readonly="no"> |
| <descr> |
| <p>Request frame borders. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-frameborder" form="simple" show="embed" actuate="auto">frameborder attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="height" id="ID-1678118" readonly="no"> |
| <descr> |
| <p>Frame height. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-height-IFRAME" form="simple" show="embed" actuate="auto">height attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="longDesc" id="ID-70472105" readonly="no"> |
| <descr> |
| <p>URI designating a long description of this image or frame. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-longdesc-IFRAME" form="simple" show="embed" actuate="auto">longdesc attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="marginHeight" id="ID-91371294" readonly="no"> |
| <descr> |
| <p>Frame margin height, in pixels. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-marginheight" form="simple" show="embed" actuate="auto">marginheight attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="marginWidth" id="ID-66486595" readonly="no"> |
| <descr> |
| <p>Frame margin width, in pixels. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-marginwidth" form="simple" show="embed" actuate="auto">marginwidth attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="name" id="ID-96819659" readonly="no"> |
| <descr> |
| <p>The frame name (object of the<code>target</code>attribute). See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-name-IFRAME" form="simple" show="embed" actuate="auto">name attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="scrolling" id="ID-36369822" readonly="no"> |
| <descr> |
| <p>Specify whether or not the frame should have scrollbars. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-scrolling" form="simple" show="embed" actuate="auto">scrolling attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="src" id="ID-43933957" readonly="no"> |
| <descr> |
| <p>A URI designating the initial frame contents. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-src-FRAME" form="simple" show="embed" actuate="auto">src attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="width" id="ID-67133005" readonly="no"> |
| <descr> |
| <p>Frame width. See the<loc href="http://www.w3.org/TR/REC-html40/present/frames.html#adef-width-IFRAME" form="simple" show="embed" actuate="auto">width attribute definition</loc>in HTML 4.0.</p> |
| </descr> |
| </attribute> |
| </interface> |
| </library> |
| /contrib/network/netsurf/libdom/test/dom2-core-interface.xml |
|---|
| 0,0 → 1,35 |
| <?xml version="1.0"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Document |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!--This file is an extract of interface definitions from Document Object Model (DOM) Level 2 Core Specification--> |
| <library> |
| <exception name="DOMException" id="ID-17189187"><descr><p>DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impossible to perform (either for logical reasons, because data is lost, or because the implementation has become unstable). In general, DOM methods return specific error values in ordinary processing situations, such as out-of-bound errors when using<code>NodeList</code>.</p><p>Implementations should raise other exceptions under other circumstances. For example, implementations should raise an implementation-dependent exception if a<code>null</code>argument is passed.</p><p>Some languages and object systems do not support the concept of exceptions. For such systems, error conditions may be indicated using native error reporting mechanisms. For some bindings, for example, methods may return error codes similar to those listed in the corresponding method descriptions.</p></descr><component id="ID-146F692A" name="code"><typename>unsigned short</typename></component></exception> |
| <group id="ID-258A00AF" name="ExceptionCode"><descr><p>An integer indicating the type of error generated.</p><note><p>Other numeric codes are reserved for W3C for possible future use.</p></note></descr><constant name="INDEX_SIZE_ERR" type="unsigned short" value="1"><descr><p>If index or size is negative, or greater than the allowed value</p></descr></constant><constant name="DOMSTRING_SIZE_ERR" type="unsigned short" value="2"><descr><p>If the specified range of text does not fit into a DOMString</p></descr></constant><constant name="HIERARCHY_REQUEST_ERR" type="unsigned short" value="3"><descr><p>If any node is inserted somewhere it doesn't belong</p></descr></constant><constant name="WRONG_DOCUMENT_ERR" type="unsigned short" value="4"><descr><p>If a node is used in a different document than the one that created it (that doesn't support it)</p></descr></constant><constant name="INVALID_CHARACTER_ERR" type="unsigned short" value="5"><descr><p>If an invalid or illegal character is specified, such as in a name. Seein the XML specification for the definition of a legal character, andfor the definition of a legal name character.</p></descr></constant><constant name="NO_DATA_ALLOWED_ERR" type="unsigned short" value="6"><descr><p>If data is specified for a node which does not support data</p></descr></constant><constant name="NO_MODIFICATION_ALLOWED_ERR" type="unsigned short" value="7"><descr><p>If an attempt is made to modify an object where modifications are not allowed</p></descr></constant><constant name="NOT_FOUND_ERR" type="unsigned short" value="8"><descr><p>If an attempt is made to reference a node in a context where it does not exist</p></descr></constant><constant name="NOT_SUPPORTED_ERR" type="unsigned short" value="9"><descr><p>If the implementation does not support the requested type of object or operation.</p></descr></constant><constant name="INUSE_ATTRIBUTE_ERR" type="unsigned short" value="10"><descr><p>If an attempt is made to add an attribute that is already in use elsewhere</p></descr></constant><constant name="INVALID_STATE_ERR" type="unsigned short" value="11" since="DOM Level 2"><descr><p>If an attempt is made to use an object that is not, or is no longer, usable.</p></descr></constant><constant name="SYNTAX_ERR" type="unsigned short" value="12" since="DOM Level 2"><descr><p>If an invalid or illegal string is specified.</p></descr></constant><constant name="INVALID_MODIFICATION_ERR" type="unsigned short" value="13" since="DOM Level 2"><descr><p>If an attempt is made to modify the type of the underlying object.</p></descr></constant><constant name="NAMESPACE_ERR" type="unsigned short" value="14" since="DOM Level 2"><descr><p>If an attempt is made to create or change an object in a way which is incorrect with regard to namespaces.</p></descr></constant><constant name="INVALID_ACCESS_ERR" type="unsigned short" value="15" since="DOM Level 2"><descr><p>If a parameter or an operation is not supported by the underlying object.</p></descr></constant></group> |
| <interface name="DOMImplementation" id="ID-102161490"><descr><p>The<code>DOMImplementation</code>interface provides a number of methods for performing operations that are independent of any particular instance of the document object model.</p></descr><method name="hasFeature" id="ID-5CED94D7"><descr><p>Test if the DOM implementation implements a specific feature.</p></descr><parameters><param name="feature" type="DOMString" attr="in"><descr><p>The name of the feature to test (case-insensitive). The values used by DOM features are defined throughout the DOM Level 2 specifications and listed in the<specref ref="ID-Conformance"/>section. The name must be an<termref def="dt-XML-name">XML name</termref>. To avoid possible conflicts, as a convention, names referring to features defined outside the DOM specification should be made unique by reversing the name of the Internet domain name of the person (or the organization that the person belongs to) who defines the feature, component by component, and using this as a prefix. For instance, the W3C SVG Working Group defines the feature "org.w3c.dom.svg".</p></descr></param><param name="version" type="DOMString" attr="in"><descr><p>This is the version number of the feature to test. In Level 2, the string can be either "2.0" or "1.0". If the version is not specified, supporting any version of the feature causes the method to return<code>true</code>.</p></descr></param></parameters><returns type="boolean"><descr><p><code>true</code>if the feature is implemented in the specified version,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><method name="createDocumentType" id="Level-2-Core-DOM-createDocType" since="DOM Level 2"><descr><p>Creates an empty<code>DocumentType</code>node. Entity declarations and notations are not made available. Entity reference expansions and default attribute additions do not occur. It is expected that a future version of the DOM will provide a way for populating a<code>DocumentType</code>.</p><p>HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The<termref def="dt-qualifiedname">qualified name</termref>of the document type to be created.</p></descr></param><param name="publicId" type="DOMString" attr="in"><descr><p>The external subset public identifier.</p></descr></param><param name="systemId" type="DOMString" attr="in"><descr><p>The external subset system identifier.</p></descr></param></parameters><returns type="DocumentType"><descr><p>A new<code>DocumentType</code>node with<code>Node.ownerDocument</code>set to<code>null</code>.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is malformed.</p></descr></exception></raises></method><method name="createDocument" id="Level-2-Core-DOM-createDocument" since="DOM Level 2"><descr><p>Creates an XML<code>Document</code>object of the specified type with its document element. HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the document element to create.</p></descr></param><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The<termref def="dt-qualifiedname">qualified name</termref>of the document element to be created.</p></descr></param><param name="doctype" type="DocumentType" attr="in"><descr><p>The type of document to be created or<code>null</code>.</p><p>When<code>doctype</code>is not<code>null</code>, its<code>Node.ownerDocument</code>attribute is set to the document being created.</p></descr></param></parameters><returns type="Document"><descr><p>A new<code>Document</code>object.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is malformed, if the<code>qualifiedName</code>has a prefix and the<code>namespaceURI</code>is<code>null</code>, or if the<code>qualifiedName</code>has a prefix that is "xml" and the<code>namespaceURI</code>is different from ""<bibref ref="Namespaces"/>.</p><p>WRONG_DOCUMENT_ERR: Raised if<code>doctype</code>has already been used with a different document or was created from a different implementation.</p><p>NOT_SUPPORTED_ERR: May be raised by DOM implementations which do not support the "XML" feature, if they choose not to support this method. Note: Other features introduced in the future, by the DOM WG or in extensions defined by other groups, may also demand support for this method; please consult the definition of the feature to see if it requires this method.</p></descr></exception></raises></method></interface> |
| <interface name="DocumentFragment" inherits="Node" id="ID-B63ED1A3"><descr><p><code>DocumentFragment</code>is a "lightweight" or "minimal"<code>Document</code>object. It is very common to want to be able to extract a portion of a document's tree or to create a new fragment of a document. Imagine implementing a user command like cut or rearranging a document by moving fragments around. It is desirable to have an object which can hold such fragments and it is quite natural to use a Node for this purpose. While it is true that a<code>Document</code>object could fulfill this role, a<code>Document</code>object can potentially be a heavyweight object, depending on the underlying implementation. What is really needed for this is a very lightweight object.<code>DocumentFragment</code>is such an object.</p><p>Furthermore, various operations -- such as inserting nodes as children of another<code>Node</code>-- may take<code>DocumentFragment</code>objects as arguments; this results in all the child nodes of the<code>DocumentFragment</code>being moved to the child list of this node.</p><p>The children of a<code>DocumentFragment</code>node are zero or more nodes representing the tops of any sub-trees defining the structure of the document.<code>DocumentFragment</code>nodes do not need to be<termref def="dt-well-formed">well-formed XML documents</termref>(although they do need to follow the rules imposed upon well-formed XML parsed entities, which can have multiple top nodes). For example, a<code>DocumentFragment</code>might have only one child and that child node could be a<code>Text</code>node. Such a structure model represents neither an HTML document nor a well-formed XML document.</p><p>When a<code>DocumentFragment</code>is inserted into a<code>Document</code>(or indeed any other<code>Node</code>that may take children) the children of the<code>DocumentFragment</code>and not the<code>DocumentFragment</code>itself are inserted into the<code>Node</code>. This makes the<code>DocumentFragment</code>very useful when the user wishes to create nodes that are<termref def="dt-sibling">siblings</termref>; the<code>DocumentFragment</code>acts as the parent of these nodes so that the user can use the standard methods from the<code>Node</code>interface, such as<code>insertBefore</code>and<code>appendChild</code>.</p></descr></interface> |
| <interface name="Document" inherits="Node" id="i-Document"><descr><p>The<code>Document</code>interface represents the entire HTML or XML document. Conceptually, it is the<termref def="dt-root-node">root</termref>of the document tree, and provides the primary access to the document's data.</p><p>Since elements, text nodes, comments, processing instructions, etc. cannot exist outside the context of a<code>Document</code>, the<code>Document</code>interface also contains the factory methods needed to create these objects. The<code>Node</code>objects created have a<code>ownerDocument</code>attribute which associates them with the<code>Document</code>within whose context they were created.</p></descr><attribute readonly="yes" name="doctype" type="DocumentType" id="ID-B63ED1A31"><descr><p>The Document Type Declaration (see<code>DocumentType</code>) associated with this document. For HTML documents as well as XML documents without a document type declaration this returns<code>null</code>. The DOM Level 2 does not support editing the Document Type Declaration.<code>docType</code>cannot be altered in any way, including through the use of methods inherited from the<code>Node</code>interface, such as<code>insertNode</code>or<code>removeNode</code>.</p></descr></attribute><attribute readonly="yes" name="implementation" type="DOMImplementation" id="ID-1B793EBA"><descr><p>The<code>DOMImplementation</code>object that handles this document. A DOM application may use objects from multiple implementations.</p></descr></attribute><attribute readonly="yes" name="documentElement" type="Element" id="ID-87CD092"><descr><p>This is a<termref def="dt-convenience">convenience</termref>attribute that allows direct access to the child node that is the root element of the document. For HTML documents, this is the element with the tagName "HTML".</p></descr></attribute><method name="createElement" id="ID-2141741547"><descr><p>Creates an element of the type specified. Note that the instance returned implements the<code>Element</code>interface, so attributes can be specified directly on the returned object.</p><p>In addition, if there are known attributes with default values,<code>Attr</code>nodes representing them are automatically created and attached to the element.</p><p>To create an element with a qualified name and namespace URI, use the<code>createElementNS</code>method.</p></descr><parameters><param name="tagName" type="DOMString" attr="in"><descr><p>The name of the element type to instantiate. For XML, this is case-sensitive. For HTML, the<code>tagName</code>parameter may be provided in any case, but it must be mapped to the canonical uppercase form by the DOM implementation.</p></descr></param></parameters><returns type="Element"><descr><p>A new<code>Element</code>object with the<code>nodeName</code>attribute set to<code>tagName</code>, and<code>localName</code>,<code>prefix</code>, and<code>namespaceURI</code>set to<code>null</code>.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified name contains an illegal character.</p></descr></exception></raises></method><method name="createDocumentFragment" id="ID-35CB04B5"><descr><p>Creates an empty<code>DocumentFragment</code>object.</p></descr><parameters></parameters><returns type="DocumentFragment"><descr><p>A new<code>DocumentFragment</code>.</p></descr></returns><raises></raises></method><method name="createTextNode" id="ID-1975348127"><descr><p>Creates a<code>Text</code>node given the specified string.</p></descr><parameters><param name="data" type="DOMString" attr="in"><descr><p>The data for the node.</p></descr></param></parameters><returns type="Text"><descr><p>The new<code>Text</code>object.</p></descr></returns><raises></raises></method><method name="createComment" id="ID-1334481328"><descr><p>Creates a<code>Comment</code>node given the specified string.</p></descr><parameters><param name="data" type="DOMString" attr="in"><descr><p>The data for the node.</p></descr></param></parameters><returns type="Comment"><descr><p>The new<code>Comment</code>object.</p></descr></returns><raises></raises></method><method name="createCDATASection" id="ID-D26C0AF8"><descr><p>Creates a<code>CDATASection</code>node whose value is the specified string.</p></descr><parameters><param name="data" type="DOMString" attr="in"><descr><p>The data for the<code>CDATASection</code>contents.</p></descr></param></parameters><returns type="CDATASection"><descr><p>The new<code>CDATASection</code>object.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.</p></descr></exception></raises></method><method name="createProcessingInstruction" id="ID-135944439"><descr><p>Creates a<code>ProcessingInstruction</code>node given the specified name and data strings.</p></descr><parameters><param name="target" type="DOMString" attr="in"><descr><p>The target part of the processing instruction.</p></descr></param><param name="data" type="DOMString" attr="in"><descr><p>The data for the node.</p></descr></param></parameters><returns type="ProcessingInstruction"><descr><p>The new<code>ProcessingInstruction</code>object.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified target contains an illegal character.</p><p>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.</p></descr></exception></raises></method><method name="createAttribute" id="ID-1084891198"><descr><p>Creates an<code>Attr</code>of the given name. Note that the<code>Attr</code>instance can then be set on an<code>Element</code>using the<code>setAttributeNode</code>method.</p><p>To create an attribute with a qualified name and namespace URI, use the<code>createAttributeNS</code>method.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute.</p></descr></param></parameters><returns type="Attr"><descr><p>A new<code>Attr</code>object with the<code>nodeName</code>attribute set to<code>name</code>, and<code>localName</code>,<code>prefix</code>, and<code>namespaceURI</code>set to<code>null</code>. The value of the attribute is the empty string.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified name contains an illegal character.</p></descr></exception></raises></method><method name="createEntityReference" id="ID-392B75AE"><descr><p>Creates an<code>EntityReference</code>object. In addition, if the referenced entity is known, the child list of the<code>EntityReference</code>node is made the same as that of the corresponding<code>Entity</code>node.</p><note><p>If any descendant of the<code>Entity</code>node has an unbound<termref def="dt-namespaceprefix">namespace prefix</termref>, the corresponding descendant of the created<code>EntityReference</code>node is also unbound; (its<code>namespaceURI</code>is<code>null</code>). The DOM Level 2 does not support any mechanism to resolve namespace prefixes.</p></note></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the entity to reference.</p></descr></param></parameters><returns type="EntityReference"><descr><p>The new<code>EntityReference</code>object.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified name contains an illegal character.</p><p>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.</p></descr></exception></raises></method><method name="getElementsByTagName" id="ID-A6C9094"><descr><p>Returns a<code>NodeList</code>of all the<code>Elements</code>with a given tag name in the order in which they are encountered in a preorder traversal of the<code>Document</code>tree.</p></descr><parameters><param name="tagname" type="DOMString" attr="in"><descr><p>The name of the tag to match on. The special value "*" matches all tags.</p></descr></param></parameters><returns type="NodeList"><descr><p>A new<code>NodeList</code>object containing all the matched<code>Elements</code>.</p></descr></returns><raises></raises></method><method name="importNode" id="Core-Document-importNode" since="DOM Level 2"><descr><p>Imports a node from another document to this document. The returned node has no parent; (<code>parentNode</code>is<code>null</code>). The source node is not altered or removed from the original document; this method creates a new copy of the source node.</p><p>For all nodes, importing a node creates a node object owned by the importing document, with attribute values identical to the source node's<code>nodeName</code>and<code>nodeType</code>, plus the attributes related to namespaces (<code>prefix</code>,<code>localName</code>, and<code>namespaceURI</code>). As in the<code>cloneNode</code>operation on a<code>Node</code>, the source node is not altered.</p><p>Additional information is copied as appropriate to the<code>nodeType</code>, attempting to mirror the behavior expected if a fragment of XML or HTML source was copied from one document to another, recognizing that the two documents may have different DTDs in the XML case. The following list describes the specifics for each type of node.<glist><gitem><label>ATTRIBUTE_NODE</label><def><p>The<code>ownerElement</code>attribute is set to<code>null</code>and the<code>specified</code>flag is set to<code>true</code>on the generated<code>Attr</code>. The<termref def="dt-descendant">descendants</termref>of the source<code>Attr</code>are recursively imported and the resulting nodes reassembled to form the corresponding subtree.</p><p>Note that the<code>deep</code>parameter has no effect on<code>Attr</code>nodes; they always carry their children with them when imported.</p></def></gitem><gitem><label>DOCUMENT_FRAGMENT_NODE</label><def><p>If the<code>deep</code>option was set to<code>true</code>, the<termref def="dt-descendant">descendants</termref>of the source element are recursively imported and the resulting nodes reassembled to form the corresponding subtree. Otherwise, this simply generates an empty<code>DocumentFragment</code>.</p></def></gitem><gitem><label>DOCUMENT_NODE</label><def><p><code>Document</code>nodes cannot be imported.</p></def></gitem><gitem><label>DOCUMENT_TYPE_NODE</label><def><p><code>DocumentType</code>nodes cannot be imported.</p></def></gitem><gitem><label>ELEMENT_NODE</label><def><p><emph>Specified</emph>attribute nodes of the source element are imported, and the generated<code>Attr</code>nodes are attached to the generated<code>Element</code>. Default attributes are<emph>not</emph>copied, though if the document being imported into defines default attributes for this element name, those are assigned. If the<code>importNode</code><code>deep</code>parameter was set to<code>true</code>, the<termref def="dt-descendant">descendants</termref>of the source element are recursively imported and the resulting nodes reassembled to form the corresponding subtree.</p></def></gitem><gitem><label>ENTITY_NODE</label><def><p><code>Entity</code>nodes can be imported, however in the current release of the DOM the<code>DocumentType</code>is readonly. Ability to add these imported nodes to a<code>DocumentType</code>will be considered for addition to a future release of the DOM.</p><p>On import, the<code>publicId</code>,<code>systemId</code>, and<code>notationName</code>attributes are copied. If a<code>deep</code>import is requested, the<termref def="dt-descendant">descendants</termref>of the the source<code>Entity</code>are recursively imported and the resulting nodes reassembled to form the corresponding subtree.</p></def></gitem><gitem><label>ENTITY_REFERENCE_NODE</label><def><p>Only the<code>EntityReference</code>itself is copied, even if a<code>deep</code>import is requested, since the source and destination documents might have defined the entity differently. If the document being imported into provides a definition for this entity name, its value is assigned.</p></def></gitem><gitem><label>NOTATION_NODE</label><def><p><code>Notation</code>nodes can be imported, however in the current release of the DOM the<code>DocumentType</code>is readonly. Ability to add these imported nodes to a<code>DocumentType</code>will be considered for addition to a future release of the DOM.</p><p>On import, the<code>publicId</code>and<code>systemId</code>attributes are copied.</p><p>Note that the<code>deep</code>parameter has no effect on<code>Notation</code>nodes since they never have any children.</p></def></gitem><gitem><label>PROCESSING_INSTRUCTION_NODE</label><def><p>The imported node copies its<code>target</code>and<code>data</code>values from those of the source node.</p></def></gitem><gitem><label>TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE</label><def><p>These three types of nodes inheriting from<code>CharacterData</code>copy their<code>data</code>and<code>length</code>attributes from those of the source node.</p></def></gitem></glist></p></descr><parameters><param name="importedNode" type="Node" attr="in"><descr><p>The node to import.</p></descr></param><param name="deep" type="boolean" attr="in"><descr><p>If<code>true</code>, recursively import the subtree under the specified node; if<code>false</code>, import only the node itself, as explained above. This has no effect on<code>Attr</code>,<code>EntityReference</code>, and<code>Notation</code>nodes.</p></descr></param></parameters><returns type="Node"><descr><p>The imported node that belongs to this<code>Document</code>.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: Raised if the type of node being imported is not supported.</p></descr></exception></raises></method><method name="createElementNS" id="ID-DocCrElNS" since="DOM Level 2"><descr><p>Creates an element of the given qualified name and namespace URI. HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the element to create.</p></descr></param><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The<termref def="dt-qualifiedname">qualified name</termref>of the element type to instantiate.</p></descr></param></parameters><returns type="Element"><descr><p>A new<code>Element</code>object with the following attributes:</p><table summary="Layout table: the first cell the name property, the second cell contains his initial value"><tbody><tr><th rowspan="1" colspan="1">Attribute</th><th rowspan="1" colspan="1">Value</th></tr><tr><td rowspan="1" colspan="1"><code>Node.nodeName</code></td><td rowspan="1" colspan="1"><code>qualifiedName</code></td></tr><tr><td rowspan="1" colspan="1"><code>Node.namespaceURI</code></td><td rowspan="1" colspan="1"><code>namespaceURI</code></td></tr><tr><td rowspan="1" colspan="1"><code>Node.prefix</code></td><td rowspan="1" colspan="1">prefix, extracted from<code>qualifiedName</code>, or<code>null</code>if there is no prefix</td></tr><tr><td rowspan="1" colspan="1"><code>Node.localName</code></td><td rowspan="1" colspan="1"><termref def="dt-localname">local name</termref>, extracted from<code>qualifiedName</code></td></tr><tr><td rowspan="1" colspan="1"><code>Element.tagName</code></td><td rowspan="1" colspan="1"><code>qualifiedName</code></td></tr></tbody></table></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is malformed, if the<code>qualifiedName</code>has a prefix and the<code>namespaceURI</code>is<code>null</code>, or if the<code>qualifiedName</code>has a prefix that is "xml" and the<code>namespaceURI</code>is different from ""<bibref ref="Namespaces"/>.</p></descr></exception></raises></method><method name="createAttributeNS" id="ID-DocCrAttrNS" since="DOM Level 2"><descr><p>Creates an attribute of the given qualified name and namespace URI. HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to create.</p></descr></param><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The<termref def="dt-qualifiedname">qualified name</termref>of the attribute to instantiate.</p></descr></param></parameters><returns type="Attr"><descr><p>A new<code>Attr</code>object with the following attributes:</p><table summary="Layout table: the first cell the name property, the second cell contains his initial value"><tbody><tr><th rowspan="1" colspan="1">Attribute</th><th rowspan="1" colspan="1">Value</th></tr><tr><td rowspan="1" colspan="1"><code>Node.nodeName</code></td><td rowspan="1" colspan="1">qualifiedName</td></tr><tr><td rowspan="1" colspan="1"><code>Node.namespaceURI</code></td><td rowspan="1" colspan="1"><code>namespaceURI</code></td></tr><tr><td rowspan="1" colspan="1"><code>Node.prefix</code></td><td rowspan="1" colspan="1">prefix, extracted from<code>qualifiedName</code>, or<code>null</code>if there is no prefix</td></tr><tr><td rowspan="1" colspan="1"><code>Node.localName</code></td><td rowspan="1" colspan="1"><termref def="dt-localname">local name</termref>, extracted from<code>qualifiedName</code></td></tr><tr><td rowspan="1" colspan="1"><code>Attr.name</code></td><td rowspan="1" colspan="1"><code>qualifiedName</code></td></tr><tr><td rowspan="1" colspan="1"><code>Node.nodeValue</code></td><td rowspan="1" colspan="1">the empty string</td></tr></tbody></table></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is malformed, if the<code>qualifiedName</code>has a prefix and the<code>namespaceURI</code>is<code>null</code>, if the<code>qualifiedName</code>has a prefix that is "xml" and the<code>namespaceURI</code>is different from "", or if the<code>qualifiedName</code>is "xmlns" and the<code>namespaceURI</code>is different from "".</p></descr></exception></raises></method><method name="getElementsByTagNameNS" id="ID-getElBTNNS" since="DOM Level 2"><descr><p>Returns a<code>NodeList</code>of all the<code>Elements</code>with a given<termref def="dt-localname">local name</termref>and namespace URI in the order in which they are encountered in a preorder traversal of the<code>Document</code>tree.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the elements to match on. The special value "*" matches all namespaces.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the elements to match on. The special value "*" matches all local names.</p></descr></param></parameters><returns type="NodeList"><descr><p>A new<code>NodeList</code>object containing all the matched<code>Elements</code>.</p></descr></returns><raises></raises></method><method name="getElementById" id="ID-getElBId" since="DOM Level 2"><descr><p>Returns the<code>Element</code>whose<code>ID</code>is given by<code>elementId</code>. If no such element exists, returns<code>null</code>. Behavior is not defined if more than one element has this<code>ID</code>.<note><p>The DOM implementation must have information that says which attributes are of type ID. Attributes with the name "ID" are not of type ID unless so defined. Implementations that do not know whether attributes are of type ID or not are expected to return<code>null</code>.</p></note></p></descr><parameters><param name="elementId" type="DOMString" attr="in"><descr><p>The unique<code>id</code>value for an element.</p></descr></param></parameters><returns type="Element"><descr><p>The matching element.</p></descr></returns><raises></raises></method></interface> |
| <interface name="Node" id="ID-1950641247"><descr><p>The<code>Node</code>interface is the primary datatype for the entire Document Object Model. It represents a single node in the document tree. While all objects implementing the<code>Node</code>interface expose methods for dealing with children, not all objects implementing the<code>Node</code>interface may have children. For example,<code>Text</code>nodes may not have children, and adding children to such nodes results in a<code>DOMException</code>being raised.</p><p>The attributes<code>nodeName</code>,<code>nodeValue</code>and<code>attributes</code>are included as a mechanism to get at node information without casting down to the specific derived interface. In cases where there is no obvious mapping of these attributes for a specific<code>nodeType</code>(e.g.,<code>nodeValue</code>for an<code>Element</code>or<code>attributes</code>for a<code>Comment</code>), this returns<code>null</code>. Note that the specialized interfaces may contain additional and more convenient mechanisms to get and set the relevant information.</p></descr><group id="ID-1841493061" name="NodeType"><descr><p>An integer indicating which type of node this is.</p><note><p>Numeric codes up to 200 are reserved to W3C for possible future use.</p></note></descr><constant name="ELEMENT_NODE" type="unsigned short" value="1"><descr><p>The node is an<code>Element</code>.</p></descr></constant><constant name="ATTRIBUTE_NODE" type="unsigned short" value="2"><descr><p>The node is an<code>Attr</code>.</p></descr></constant><constant name="TEXT_NODE" type="unsigned short" value="3"><descr><p>The node is a<code>Text</code>node.</p></descr></constant><constant name="CDATA_SECTION_NODE" type="unsigned short" value="4"><descr><p>The node is a<code>CDATASection</code>.</p></descr></constant><constant name="ENTITY_REFERENCE_NODE" type="unsigned short" value="5"><descr><p>The node is an<code>EntityReference</code>.</p></descr></constant><constant name="ENTITY_NODE" type="unsigned short" value="6"><descr><p>The node is an<code>Entity</code>.</p></descr></constant><constant name="PROCESSING_INSTRUCTION_NODE" type="unsigned short" value="7"><descr><p>The node is a<code>ProcessingInstruction</code>.</p></descr></constant><constant name="COMMENT_NODE" type="unsigned short" value="8"><descr><p>The node is a<code>Comment</code>.</p></descr></constant><constant name="DOCUMENT_NODE" type="unsigned short" value="9"><descr><p>The node is a<code>Document</code>.</p></descr></constant><constant name="DOCUMENT_TYPE_NODE" type="unsigned short" value="10"><descr><p>The node is a<code>DocumentType</code>.</p></descr></constant><constant name="DOCUMENT_FRAGMENT_NODE" type="unsigned short" value="11"><descr><p>The node is a<code>DocumentFragment</code>.</p></descr></constant><constant name="NOTATION_NODE" type="unsigned short" value="12"><descr><p>The node is a<code>Notation</code>.</p></descr></constant></group><p>The values of<code>nodeName</code>,<code>nodeValue</code>, and<code>attributes</code>vary according to the node type as follows:<table summary="Layout table: the first cell contains the name of the interface, the second contains the value of the nodeName attribute for this interface, the third contains the value of the nodeValue attribute for this interface and the fourth contains the value of the attributes attribute for this interface" border="1"><tbody><tr><th rowspan="1" colspan="1">Interface</th><th rowspan="1" colspan="1">nodeName</th><th rowspan="1" colspan="1">nodeValue</th><th rowspan="1" colspan="1">attributes</th></tr><tr><td rowspan="1" colspan="1">Attr</td><td rowspan="1" colspan="1">name of attribute</td><td rowspan="1" colspan="1">value of attribute</td><td rowspan="1" colspan="1">null</td></tr><tr><td rowspan="1" colspan="1">CDATASection</td><td rowspan="1" colspan="1">#cdata-section</td><td rowspan="1" colspan="1">content of the CDATA Section</td><td rowspan="1" colspan="1">null</td></tr><tr><td rowspan="1" colspan="1">Comment</td><td rowspan="1" colspan="1">#comment</td><td rowspan="1" colspan="1">content of the comment</td><td rowspan="1" colspan="1">null</td></tr><tr><td rowspan="1" colspan="1">Document</td><td rowspan="1" colspan="1">#document</td><td rowspan="1" colspan="1">null</td><td rowspan="1" colspan="1">null</td></tr><tr><td rowspan="1" colspan="1">DocumentFragment</td><td rowspan="1" colspan="1">#document-fragment</td><td rowspan="1" colspan="1">null</td><td rowspan="1" colspan="1">null</td></tr><tr><td rowspan="1" colspan="1">DocumentType</td><td rowspan="1" colspan="1">document type name</td><td rowspan="1" colspan="1">null</td><td rowspan="1" colspan="1">null</td></tr><tr><td rowspan="1" colspan="1">Element</td><td rowspan="1" colspan="1">tag name</td><td rowspan="1" colspan="1">null</td><td rowspan="1" colspan="1">NamedNodeMap</td></tr><tr><td rowspan="1" colspan="1">Entity</td><td rowspan="1" colspan="1">entity name</td><td rowspan="1" colspan="1">null</td><td rowspan="1" colspan="1">null</td></tr><tr><td rowspan="1" colspan="1">EntityReference</td><td rowspan="1" colspan="1">name of entity referenced</td><td rowspan="1" colspan="1">null</td><td rowspan="1" colspan="1">null</td></tr><tr><td rowspan="1" colspan="1">Notation</td><td rowspan="1" colspan="1">notation name</td><td rowspan="1" colspan="1">null</td><td rowspan="1" colspan="1">null</td></tr><tr><td rowspan="1" colspan="1">ProcessingInstruction</td><td rowspan="1" colspan="1">target</td><td rowspan="1" colspan="1">entire content excluding the target</td><td rowspan="1" colspan="1">null</td></tr><tr><td rowspan="1" colspan="1">Text</td><td rowspan="1" colspan="1">#text</td><td rowspan="1" colspan="1">content of the text node</td><td rowspan="1" colspan="1">null</td></tr></tbody></table></p><attribute type="DOMString" readonly="yes" name="nodeName" id="ID-F68D095"><descr><p>The name of this node, depending on its type; see the table above.</p></descr></attribute><attribute type="DOMString" name="nodeValue" id="ID-F68D080" readonly="no"><descr><p>The value of this node, depending on its type; see the table above. When it is defined to be<code>null</code>, setting it has no effect.</p></descr><setraises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p></descr></exception></setraises><getraises><exception name="DOMException"><descr><p>DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a<code>DOMString</code>variable on the implementation platform.</p></descr></exception></getraises></attribute><attribute type="unsigned short" name="nodeType" readonly="yes" id="ID-111237558"><descr><p>A code representing the type of the underlying object, as defined above.</p></descr></attribute><attribute type="Node" readonly="yes" name="parentNode" id="ID-1060184317"><descr><p>The<termref def="dt-parent">parent</termref>of this node. All nodes, except<code>Attr</code>,<code>Document</code>,<code>DocumentFragment</code>,<code>Entity</code>, and<code>Notation</code>may have a parent. However, if a node has just been created and not yet added to the tree, or if it has been removed from the tree, this is<code>null</code>.</p></descr></attribute><attribute type="NodeList" readonly="yes" name="childNodes" id="ID-1451460987"><descr><p>A<code>NodeList</code>that contains all children of this node. If there are no children, this is a<code>NodeList</code>containing no nodes.</p></descr></attribute><attribute readonly="yes" type="Node" name="firstChild" id="ID-169727388"><descr><p>The first child of this node. If there is no such node, this returns<code>null</code>.</p></descr></attribute><attribute readonly="yes" type="Node" name="lastChild" id="ID-61AD09FB"><descr><p>The last child of this node. If there is no such node, this returns<code>null</code>.</p></descr></attribute><attribute readonly="yes" type="Node" name="previousSibling" id="ID-640FB3C8"><descr><p>The node immediately preceding this node. If there is no such node, this returns<code>null</code>.</p></descr></attribute><attribute readonly="yes" type="Node" name="nextSibling" id="ID-6AC54C2F"><descr><p>The node immediately following this node. If there is no such node, this returns<code>null</code>.</p></descr></attribute><attribute readonly="yes" type="NamedNodeMap" name="attributes" id="ID-84CF096"><descr><p>A<code>NamedNodeMap</code>containing the attributes of this node (if it is an<code>Element</code>) or<code>null</code>otherwise.</p></descr></attribute><attribute readonly="yes" type="Document" name="ownerDocument" id="node-ownerDoc" version="DOM Level 2"><descr><p>The<code>Document</code>object associated with this node. This is also the<code>Document</code>object used to create new nodes. When this node is a<code>Document</code>or a<code>DocumentType</code>which is not used with any<code>Document</code>yet, this is<code>null</code>.</p></descr></attribute><method name="insertBefore" id="ID-952280727"><descr><p>Inserts the node<code>newChild</code>before the existing child node<code>refChild</code>. If<code>refChild</code>is<code>null</code>, insert<code>newChild</code>at the end of the list of children.</p><p>If<code>newChild</code>is a<code>DocumentFragment</code>object, all of its children are inserted, in the same order, before<code>refChild</code>. If the<code>newChild</code>is already in the tree, it is first removed.</p></descr><parameters><param name="newChild" type="Node" attr="in"><descr><p>The node to insert.</p></descr></param><param name="refChild" type="Node" attr="in"><descr><p>The reference node, i.e., the node before which the new node must be inserted.</p></descr></param></parameters><returns type="Node"><descr><p>The node being inserted.</p></descr></returns><raises><exception name="DOMException"><descr><p>HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the<code>newChild</code>node, or if the node to insert is one of this node's<termref def="dt-ancestor">ancestors</termref>.</p><p>WRONG_DOCUMENT_ERR: Raised if<code>newChild</code>was created from a different document than the one that created this node.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or if the parent of the node being inserted is readonly.</p><p>NOT_FOUND_ERR: Raised if<code>refChild</code>is not a child of this node.</p></descr></exception></raises></method><method name="replaceChild" id="ID-785887307"><descr><p>Replaces the child node<code>oldChild</code>with<code>newChild</code>in the list of children, and returns the<code>oldChild</code>node.</p><p>If<code>newChild</code>is a<code>DocumentFragment</code>object,<code>oldChild</code>is replaced by all of the<code>DocumentFragment</code>children, which are inserted in the same order. If the<code>newChild</code>is already in the tree, it is first removed.</p></descr><parameters><param name="newChild" type="Node" attr="in"><descr><p>The new node to put in the child list.</p></descr></param><param name="oldChild" type="Node" attr="in"><descr><p>The node being replaced in the list.</p></descr></param></parameters><returns type="Node"><descr><p>The node replaced.</p></descr></returns><raises><exception name="DOMException"><descr><p>HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the<code>newChild</code>node, or if the node to put in is one of this node's<termref def="dt-ancestor">ancestors</termref>.</p><p>WRONG_DOCUMENT_ERR: Raised if<code>newChild</code>was created from a different document than the one that created this node.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the parent of the new node is readonly.</p><p>NOT_FOUND_ERR: Raised if<code>oldChild</code>is not a child of this node.</p></descr></exception></raises></method><method name="removeChild" id="ID-1734834066"><descr><p>Removes the child node indicated by<code>oldChild</code>from the list of children, and returns it.</p></descr><parameters><param name="oldChild" type="Node" attr="in"><descr><p>The node being removed.</p></descr></param></parameters><returns type="Node"><descr><p>The node removed.</p></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NOT_FOUND_ERR: Raised if<code>oldChild</code>is not a child of this node.</p></descr></exception></raises></method><method name="appendChild" id="ID-184E7107"><descr><p>Adds the node<code>newChild</code>to the end of the list of children of this node. If the<code>newChild</code>is already in the tree, it is first removed.</p></descr><parameters><param name="newChild" type="Node" attr="in"><descr><p>The node to add.</p><p>If it is a<code>DocumentFragment</code>object, the entire contents of the document fragment are moved into the child list of this node</p></descr></param></parameters><returns type="Node"><descr><p>The node added.</p></descr></returns><raises><exception name="DOMException"><descr><p>HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the<code>newChild</code>node, or if the node to append is one of this node's<termref def="dt-ancestor">ancestors</termref>.</p><p>WRONG_DOCUMENT_ERR: Raised if<code>newChild</code>was created from a different document than the one that created this node.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="hasChildNodes" id="ID-810594187"><descr><p>Returns whether this node has any children.</p></descr><parameters></parameters><returns type="boolean"><descr><p><code>true</code>if this node has any children,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><method name="cloneNode" id="ID-3A0ED0A4"><descr><p>Returns a duplicate of this node, i.e., serves as a generic copy constructor for nodes. The duplicate node has no parent; (<code>parentNode</code>is<code>null</code>.).</p><p>Cloning an<code>Element</code>copies all attributes and their values, including those generated by the XML processor to represent defaulted attributes, but this method does not copy any text it contains unless it is a deep clone, since the text is contained in a child<code>Text</code>node. Cloning an<code>Attribute</code>directly, as opposed to be cloned as part of an<code>Element</code>cloning operation, returns a specified attribute (<code>specified</code>is<code>true</code>). Cloning any other type of node simply returns a copy of this node.</p><p>Note that cloning an immutable subtree results in a mutable copy, but the children of an<code>EntityReference</code>clone are<termref def="dt-readonly-node">readonly</termref>. In addition, clones of unspecified<code>Attr</code>nodes are specified. And, cloning<code>Document</code>,<code>DocumentType</code>,<code>Entity</code>, and<code>Notation</code>nodes is implementation dependent.</p></descr><parameters><param name="deep" type="boolean" attr="in"><descr><p>If<code>true</code>, recursively clone the subtree under the specified node; if<code>false</code>, clone only the node itself (and its attributes, if it is an<code>Element</code>).</p></descr></param></parameters><returns type="Node"><descr><p>The duplicate node.</p></descr></returns><raises></raises></method><method id="ID-normalize" name="normalize" version="DOM Level 2"><descr><p>Puts all<code>Text</code>nodes in the full depth of the sub-tree underneath this<code>Node</code>, including attribute nodes, into a "normal" form where only structure (e.g., elements, comments, processing instructions, CDATA sections, and entity references) separates<code>Text</code>nodes, i.e., there are neither adjacent<code>Text</code>nodes nor empty<code>Text</code>nodes. This can be used to ensure that the DOM view of a document is the same as if it were saved and re-loaded, and is useful when operations (such as XPointer<bibref ref="XPointer"/>lookups) that depend on a particular document tree structure are to be used.</p><note><p>In cases where the document contains<code>CDATASections</code>, the normalize operation alone may not be sufficient, since XPointers do not differentiate between<code>Text</code>nodes and<code>CDATASection</code>nodes.</p></note></descr><parameters></parameters><returns type="void"><descr><p/></descr></returns><raises></raises></method><method name="isSupported" id="Level-2-Core-Node-supports" since="DOM Level 2"><descr><p>Tests whether the DOM implementation implements a specific feature and that feature is supported by this node.</p></descr><parameters><param name="feature" type="DOMString" attr="in"><descr><p>The name of the feature to test. This is the same name which can be passed to the method<code>hasFeature</code>on<code>DOMImplementation</code>.</p></descr></param><param name="version" type="DOMString" attr="in"><descr><p>This is the version number of the feature to test. In Level 2, version 1, this is the string "2.0". If the version is not specified, supporting any version of the feature will cause the method to return<code>true</code>.</p></descr></param></parameters><returns type="boolean"><descr><p>Returns<code>true</code>if the specified feature is supported on this node,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><attribute readonly="yes" type="DOMString" name="namespaceURI" id="ID-NodeNSname" since="DOM Level 2"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of this node, or<code>null</code>if it is unspecified.</p><p>This is not a computed value that is the result of a namespace lookup based on an examination of the namespace declarations in scope. It is merely the namespace URI given at creation time.</p><p>For nodes of any type other than<code>ELEMENT_NODE</code>and<code>ATTRIBUTE_NODE</code>and nodes created with a DOM Level 1 method, such as<code>createElement</code>from the<code>Document</code>interface, this is always<code>null</code>.</p><note><p>Per the<emph>Namespaces in XML</emph>Specification<bibref ref="Namespaces"/>an attribute does not inherit its namespace from the element it is attached to. If an attribute is not explicitly given a namespace, it simply has no namespace.</p></note></descr></attribute><attribute type="DOMString" name="prefix" id="ID-NodeNSPrefix" since="DOM Level 2" readonly="no"><descr><p>The<termref def="dt-namespaceprefix">namespace prefix</termref>of this node, or<code>null</code>if it is unspecified.</p><p>Note that setting this attribute, when permitted, changes the<code>nodeName</code>attribute, which holds the<termref def="dt-qualifiedname">qualified name</termref>, as well as the<code>tagName</code>and<code>name</code>attributes of the<code>Element</code>and<code>Attr</code>interfaces, when applicable.</p><p>Note also that changing the prefix of an attribute that is known to have a default value, does not make a new attribute with the default value and the original prefix appear, since the<code>namespaceURI</code>and<code>localName</code>do not change.</p><p>For nodes of any type other than<code>ELEMENT_NODE</code>and<code>ATTRIBUTE_NODE</code>and nodes created with a DOM Level 1 method, such as<code>createElement</code>from the<code>Document</code>interface, this is always<code>null</code>.</p></descr><setraises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NAMESPACE_ERR: Raised if the specified<code>prefix</code>is malformed, if the<code>namespaceURI</code>of this node is<code>null</code>, if the specified prefix is "xml" and the<code>namespaceURI</code>of this node is different from "", if this node is an attribute and the specified prefix is "xmlns" and the<code>namespaceURI</code>of this node is different from "", or if this node is an attribute and the<code>qualifiedName</code>of this node is "xmlns"<bibref ref="Namespaces"/>.</p></descr></exception></setraises></attribute><attribute readonly="yes" type="DOMString" name="localName" id="ID-NodeNSLocalN" since="DOM Level 2"><descr><p>Returns the local part of the<termref def="dt-qualifiedname">qualified name</termref>of this node.</p><p>For nodes of any type other than<code>ELEMENT_NODE</code>and<code>ATTRIBUTE_NODE</code>and nodes created with a DOM Level 1 method, such as<code>createElement</code>from the<code>Document</code>interface, this is always<code>null</code>.</p></descr></attribute><method name="hasAttributes" id="ID-NodeHasAttrs" since="DOM Level 2"><descr><p>Returns whether this node (if it is an element) has any attributes.</p></descr><parameters></parameters><returns type="boolean"><descr><p><code>true</code>if this node has any attributes,<code>false</code>otherwise.</p></descr></returns><raises></raises></method></interface> |
| <interface name="NodeList" id="ID-536297177"><descr><p>The<code>NodeList</code>interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented.<code>NodeList</code>objects in the DOM are<termref def="td-live">live</termref>.</p><p>The items in the<code>NodeList</code>are accessible via an integral index, starting from 0.</p></descr><method name="item" id="ID-844377136"><descr><p>Returns the<code>index</code>th item in the collection. If<code>index</code>is greater than or equal to the number of nodes in the list, this returns<code>null</code>.</p></descr><parameters><param name="index" type="unsigned long" attr="in"><descr><p>Index into the collection.</p></descr></param></parameters><returns type="Node"><descr><p>The node at the<code>index</code>th position in the<code>NodeList</code>, or<code>null</code>if that is not a valid index.</p></descr></returns><raises></raises></method><attribute type="unsigned long" readonly="yes" name="length" id="ID-203510337"><descr><p>The number of nodes in the list. The range of valid child node indices is 0 to<code>length-1</code>inclusive.</p></descr></attribute></interface> |
| <interface name="NamedNodeMap" id="ID-1780488922"><descr><p>Objects implementing the<code>NamedNodeMap</code>interface are used to represent collections of nodes that can be accessed by name. Note that<code>NamedNodeMap</code>does not inherit from<code>NodeList</code>;<code>NamedNodeMaps</code>are not maintained in any particular order. Objects contained in an object implementing<code>NamedNodeMap</code>may also be accessed by an ordinal index, but this is simply to allow convenient enumeration of the contents of a<code>NamedNodeMap</code>, and does not imply that the DOM specifies an order to these Nodes.</p><p><code>NamedNodeMap</code>objects in the DOM are<termref def="td-live">live</termref>.</p></descr><method name="getNamedItem" id="ID-1074577549"><descr><p>Retrieves a node specified by name.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The<code>nodeName</code>of a node to retrieve.</p></descr></param></parameters><returns type="Node"><descr><p>A<code>Node</code>(of any type) with the specified<code>nodeName</code>, or<code>null</code>if it does not identify any node in this map.</p></descr></returns><raises></raises></method><method name="setNamedItem" id="ID-1025163788"><descr><p>Adds a node using its<code>nodeName</code>attribute. If a node with that name is already present in this map, it is replaced by the new one.</p><p>As the<code>nodeName</code>attribute is used to derive the name which the node must be stored under, multiple nodes of certain types (those that have a "special" string value) cannot be stored as the names would clash. This is seen as preferable to allowing nodes to be aliased.</p></descr><parameters><param name="arg" type="Node" attr="in"><descr><p>A node to store in this map. The node will later be accessible using the value of its<code>nodeName</code>attribute.</p></descr></param></parameters><returns type="Node"><descr><p>If the new<code>Node</code>replaces an existing node the replaced<code>Node</code>is returned, otherwise<code>null</code>is returned.</p></descr></returns><raises><exception name="DOMException"><descr><p>WRONG_DOCUMENT_ERR: Raised if<code>arg</code>was created from a different document than the one that created this map.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.</p><p>INUSE_ATTRIBUTE_ERR: Raised if<code>arg</code>is an<code>Attr</code>that is already an attribute of another<code>Element</code>object. The DOM user must explicitly clone<code>Attr</code>nodes to re-use them in other elements.</p><p>HIERARCHY_REQUEST_ERR: Raised if an attempt is made to add a node doesn't belong in this NamedNodeMap. Examples would include trying to insert something other than an Attr node into an Element's map of attributes, or a non-Entity node into the DocumentType's map of Entities</p></descr></exception></raises></method><method name="removeNamedItem" id="ID-D58B193"><descr><p>Removes a node specified by name. When this map contains the attributes attached to an element, if the removed attribute is known to have a default value, an attribute immediately appears containing the default value as well as the corresponding namespace URI, local name, and prefix when applicable.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The<code>nodeName</code>of the node to remove.</p></descr></param></parameters><returns type="Node"><descr><p>The node removed from this map if a node with such a name exists.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_FOUND_ERR: Raised if there is no node named<code>name</code>in this map.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.</p></descr></exception></raises></method><method name="item" id="ID-349467F9"><descr><p>Returns the<code>index</code>th item in the map. If<code>index</code>is greater than or equal to the number of nodes in this map, this returns<code>null</code>.</p></descr><parameters><param name="index" type="unsigned long" attr="in"><descr><p>Index into this map.</p></descr></param></parameters><returns type="Node"><descr><p>The node at the<code>index</code>th position in the map, or<code>null</code>if that is not a valid index.</p></descr></returns><raises></raises></method><attribute type="unsigned long" readonly="yes" name="length" id="ID-6D0FB19E"><descr><p>The number of nodes in this map. The range of valid child node indices is<code>0</code>to<code>length-1</code>inclusive.</p></descr></attribute><method name="getNamedItemNS" id="ID-getNamedItemNS" since="DOM Level 2"><descr><p>Retrieves a node specified by local name and namespace URI. HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the node to retrieve.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the node to retrieve.</p></descr></param></parameters><returns type="Node"><descr><p>A<code>Node</code>(of any type) with the specified local name and namespace URI, or<code>null</code>if they do not identify any node in this map.</p></descr></returns><raises></raises></method><method name="setNamedItemNS" id="ID-setNamedItemNS" since="DOM Level 2"><descr><p>Adds a node using its<code>namespaceURI</code>and<code>localName</code>. If a node with that namespace URI and that local name is already present in this map, it is replaced by the new one.</p><p>HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="arg" type="Node" attr="in"><descr><p>A node to store in this map. The node will later be accessible using the value of its<code>namespaceURI</code>and<code>localName</code>attributes.</p></descr></param></parameters><returns type="Node"><descr><p>If the new<code>Node</code>replaces an existing node the replaced<code>Node</code>is returned, otherwise<code>null</code>is returned.</p></descr></returns><raises><exception name="DOMException"><descr><p>WRONG_DOCUMENT_ERR: Raised if<code>arg</code>was created from a different document than the one that created this map.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.</p><p>INUSE_ATTRIBUTE_ERR: Raised if<code>arg</code>is an<code>Attr</code>that is already an attribute of another<code>Element</code>object. The DOM user must explicitly clone<code>Attr</code>nodes to re-use them in other elements.</p><p>HIERARCHY_REQUEST_ERR: Raised if an attempt is made to add a node doesn't belong in this NamedNodeMap. Examples would include trying to insert something other than an Attr node into an Element's map of attributes, or a non-Entity node into the DocumentType's map of Entities</p></descr></exception></raises></method><method name="removeNamedItemNS" id="ID-removeNamedItemNS" since="DOM Level 2"><descr><p>Removes a node specified by local name and namespace URI. A removed attribute may be known to have a default value when this map contains the attributes attached to an element, as returned by the attributes attribute of the<code>Node</code>interface. If so, an attribute immediately appears containing the default value as well as the corresponding namespace URI, local name, and prefix when applicable.</p><p>HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the node to remove.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the node to remove.</p></descr></param></parameters><returns type="Node"><descr><p>The node removed from this map if a node with such a local name and namespace URI exists.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_FOUND_ERR: Raised if there is no node with the specified<code>namespaceURI</code>and<code>localName</code>in this map.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.</p></descr></exception></raises></method></interface> |
| <interface name="CharacterData" inherits="Node" id="ID-FF21A306"><descr><p>The<code>CharacterData</code>interface extends Node with a set of attributes and methods for accessing character data in the DOM. For clarity this set is defined here rather than on each object that uses these attributes and methods. No DOM objects correspond directly to<code>CharacterData</code>, though<code>Text</code>and others do inherit the interface from it. All<code>offsets</code>in this interface start from<code>0</code>.</p><p>As explained in the<code>DOMString</code>interface, text strings in the DOM are represented in UTF-16, i.e. as a sequence of 16-bit units. In the following, the term<termref def="dt-16-bit-unit">16-bit units</termref>is used whenever necessary to indicate that indexing on CharacterData is done in 16-bit units.</p></descr><attribute type="DOMString" name="data" id="ID-72AB8359" readonly="no"><descr><p>The character data of the node that implements this interface. The DOM implementation may not put arbitrary limits on the amount of data that may be stored in a<code>CharacterData</code>node. However, implementation limits may mean that the entirety of a node's data may not fit into a single<code>DOMString</code>. In such cases, the user may call<code>substringData</code>to retrieve the data in appropriately sized pieces.</p></descr><setraises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p></descr></exception></setraises><getraises><exception name="DOMException"><descr><p>DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a<code>DOMString</code>variable on the implementation platform.</p></descr></exception></getraises></attribute><attribute type="unsigned long" name="length" readonly="yes" id="ID-7D61178C"><descr><p>The number of<termref def="dt-16-bit-unit">16-bit units</termref>that are available through<code>data</code>and the<code>substringData</code>method below. This may have the value zero, i.e.,<code>CharacterData</code>nodes may be empty.</p></descr></attribute><method name="substringData" id="ID-6531BCCF"><descr><p>Extracts a range of data from the node.</p></descr><parameters><param name="offset" type="unsigned long" attr="in"><descr><p>Start offset of substring to extract.</p></descr></param><param name="count" type="unsigned long" attr="in"><descr><p>The number of 16-bit units to extract.</p></descr></param></parameters><returns type="DOMString"><descr><p>The specified substring. If the sum of<code>offset</code>and<code>count</code>exceeds the<code>length</code>, then all 16-bit units to the end of the data are returned.</p></descr></returns><raises><exception name="DOMException"><descr><p>INDEX_SIZE_ERR: Raised if the specified<code>offset</code>is negative or greater than the number of 16-bit units in<code>data</code>, or if the specified<code>count</code>is negative.</p><p>DOMSTRING_SIZE_ERR: Raised if the specified range of text does not fit into a<code>DOMString</code>.</p></descr></exception></raises></method><method name="appendData" id="ID-32791A2F"><descr><p>Append the string to the end of the character data of the node. Upon success,<code>data</code>provides access to the concatenation of<code>data</code>and the<code>DOMString</code>specified.</p></descr><parameters><param name="arg" type="DOMString" attr="in"><descr><p>The<code>DOMString</code>to append.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="insertData" id="ID-3EDB695F"><descr><p>Insert a string at the specified<termref def="dt-16-bit-unit">16-bit unit</termref>offset.</p></descr><parameters><param name="offset" type="unsigned long" attr="in"><descr><p>The character offset at which to insert.</p></descr></param><param name="arg" type="DOMString" attr="in"><descr><p>The<code>DOMString</code>to insert.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>INDEX_SIZE_ERR: Raised if the specified<code>offset</code>is negative or greater than the number of 16-bit units in<code>data</code>.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="deleteData" id="ID-7C603781"><descr><p>Remove a range of<termref def="dt-16-bit-unit">16-bit units</termref>from the node. Upon success,<code>data</code>and<code>length</code>reflect the change.</p></descr><parameters><param name="offset" type="unsigned long" attr="in"><descr><p>The offset from which to start removing.</p></descr></param><param name="count" type="unsigned long" attr="in"><descr><p>The number of 16-bit units to delete. If the sum of<code>offset</code>and<code>count</code>exceeds<code>length</code>then all 16-bit units from<code>offset</code>to the end of the data are deleted.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>INDEX_SIZE_ERR: Raised if the specified<code>offset</code>is negative or greater than the number of 16-bit units in<code>data</code>, or if the specified<code>count</code>is negative.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="replaceData" id="ID-E5CBA7FB"><descr><p>Replace the characters starting at the specified<termref def="dt-16-bit-unit">16-bit unit</termref>offset with the specified string.</p></descr><parameters><param name="offset" type="unsigned long" attr="in"><descr><p>The offset from which to start replacing.</p></descr></param><param name="count" type="unsigned long" attr="in"><descr><p>The number of 16-bit units to replace. If the sum of<code>offset</code>and<code>count</code>exceeds<code>length</code>, then all 16-bit units to the end of the data are replaced; (i.e., the effect is the same as a<code>remove</code>method call with the same range, followed by an<code>append</code>method invocation).</p></descr></param><param name="arg" type="DOMString" attr="in"><descr><p>The<code>DOMString</code>with which the range must be replaced.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>INDEX_SIZE_ERR: Raised if the specified<code>offset</code>is negative or greater than the number of 16-bit units in<code>data</code>, or if the specified<code>count</code>is negative.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method></interface> |
| <interface name="Attr" inherits="Node" id="ID-637646024"><descr><p>The<code>Attr</code>interface represents an attribute in an<code>Element</code>object. Typically the allowable values for the attribute are defined in a document type definition.</p><p><code>Attr</code>objects inherit the<code>Node</code>interface, but since they are not actually child nodes of the element they describe, the DOM does not consider them part of the document tree. Thus, the<code>Node</code>attributes<code>parentNode</code>,<code>previousSibling</code>, and<code>nextSibling</code>have a<code>null</code>value for<code>Attr</code>objects. The DOM takes the view that attributes are properties of elements rather than having a separate identity from the elements they are associated with; this should make it more efficient to implement such features as default attributes associated with all elements of a given type. Furthermore,<code>Attr</code>nodes may not be immediate children of a<code>DocumentFragment</code>. However, they can be associated with<code>Element</code>nodes contained within a<code>DocumentFragment</code>. In short, users and implementors of the DOM need to be aware that<code>Attr</code>nodes have some things in common with other objects inheriting the<code>Node</code>interface, but they also are quite distinct.</p><p>The attribute's effective value is determined as follows: if this attribute has been explicitly assigned any value, that value is the attribute's effective value; otherwise, if there is a declaration for this attribute, and that declaration includes a default value, then that default value is the attribute's effective value; otherwise, the attribute does not exist on this element in the structure model until it has been explicitly added. Note that the<code>nodeValue</code>attribute on the<code>Attr</code>instance can also be used to retrieve the string version of the attribute's value(s).</p><p>In XML, where the value of an attribute can contain entity references, the child nodes of the<code>Attr</code>node may be either<code>Text</code>or<code>EntityReference</code>nodes (when these are in use; see the description of<code>EntityReference</code>for discussion). Because the DOM Core is not aware of attribute types, it treats all attribute values as simple strings, even if the DTD or schema declares them as having<termref def="dt-tokenized">tokenized</termref>types.</p></descr><attribute type="DOMString" readonly="yes" name="name" id="ID-1112119403"><descr><p>Returns the name of this attribute.</p></descr></attribute><attribute type="boolean" readonly="yes" name="specified" id="ID-862529273"><descr><p>If this attribute was explicitly given a value in the original document, this is<code>true</code>; otherwise, it is<code>false</code>. Note that the implementation is in charge of this attribute, not the user. If the user changes the value of the attribute (even if it ends up having the same value as the default value) then the<code>specified</code>flag is automatically flipped to<code>true</code>. To re-specify the attribute as the default value from the DTD, the user must delete the attribute. The implementation will then make a new attribute available with<code>specified</code>set to<code>false</code>and the default value (if one exists).</p><p>In summary:<ulist><item><p>If the attribute has an assigned value in the document then<code>specified</code>is<code>true</code>, and the value is the assigned value.</p></item><item><p>If the attribute has no assigned value in the document and has a default value in the DTD, then<code>specified</code>is<code>false</code>, and the value is the default value in the DTD.</p></item><item><p>If the attribute has no assigned value in the document and has a value of #IMPLIED in the DTD, then the attribute does not appear in the structure model of the document.</p></item><item><p>If the<code>ownerElement</code>attribute is<code>null</code>(i.e. because it was just created or was set to<code>null</code>by the various removal and cloning operations)<code>specified</code>is<code>true</code>.</p></item></ulist></p></descr></attribute><attribute type="DOMString" name="value" id="ID-221662474" readonly="no"><descr><p>On retrieval, the value of the attribute is returned as a string. Character and general entity references are replaced with their values. See also the method<code>getAttribute</code>on the<code>Element</code>interface.</p><p>On setting, this creates a<code>Text</code>node with the unparsed contents of the string. I.e. any characters that an XML processor would recognize as markup are instead treated as literal text. See also the method<code>setAttribute</code>on the<code>Element</code>interface.</p></descr><setraises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p></descr></exception></setraises></attribute><attribute name="ownerElement" type="Element" readonly="yes" id="Attr-ownerElement" since="DOM Level 2"><descr><p>The<code>Element</code>node this attribute is attached to or<code>null</code>if this attribute is not in use.</p></descr></attribute></interface> |
| <interface name="Element" inherits="Node" id="ID-745549614"><descr><p>The<code>Element</code>interface represents an<termref def="dt-element">element</termref>in an HTML or XML document. Elements may have attributes associated with them; since the<code>Element</code>interface inherits from<code>Node</code>, the generic<code>Node</code>interface attribute<code>attributes</code>may be used to retrieve the set of all attributes for an element. There are methods on the<code>Element</code>interface to retrieve either an<code>Attr</code>object by name or an attribute value by name. In XML, where an attribute value may contain entity references, an<code>Attr</code>object should be retrieved to examine the possibly fairly complex sub-tree representing the attribute value. On the other hand, in HTML, where all attributes have simple string values, methods to directly access an attribute value can safely be used as a<termref def="dt-convenience">convenience</termref>.</p><note><p>In DOM Level 2, the method<code>normalize</code>is inherited from the<code>Node</code>interface where it was moved.</p></note></descr><attribute type="DOMString" name="tagName" readonly="yes" id="ID-104682815"><descr><p>The name of the element. For example, in:<eg role="code" xml:space="preserve"><elementExample id="demo"> ... </elementExample> ,</eg><code>tagName</code>has the value<code>"elementExample"</code>. Note that this is case-preserving in XML, as are all of the operations of the DOM. The HTML DOM returns the<code>tagName</code>of an HTML element in the canonical uppercase form, regardless of the case in the source HTML document.</p></descr></attribute><method name="getAttribute" id="ID-666EE0F9"><descr><p>Retrieves an attribute value by name.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute to retrieve.</p></descr></param></parameters><returns type="DOMString"><descr><p>The<code>Attr</code>value as a string, or the empty string if that attribute does not have a specified or default value.</p></descr></returns><raises></raises></method><method name="setAttribute" id="ID-F68F082"><descr><p>Adds a new attribute. If an attribute with that name is already present in the element, its value is changed to be that of the value parameter. This value is a simple string; it is not parsed as it is being set. So any markup (such as syntax to be recognized as an entity reference) is treated as literal text, and needs to be appropriately escaped by the implementation when it is written out. In order to assign an attribute value that contains entity references, the user must create an<code>Attr</code>node plus any<code>Text</code>and<code>EntityReference</code>nodes, build the appropriate subtree, and use<code>setAttributeNode</code>to assign it as the value of an attribute.</p><p>To set an attribute with a qualified name and namespace URI, use the<code>setAttributeNS</code>method.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute to create or alter.</p></descr></param><param name="value" type="DOMString" attr="in"><descr><p>Value to set in string form.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified name contains an illegal character.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="removeAttribute" id="ID-6D6AC0F9"><descr><p>Removes an attribute by name. If the removed attribute is known to have a default value, an attribute immediately appears containing the default value as well as the corresponding namespace URI, local name, and prefix when applicable.</p><p>To remove an attribute by local name and namespace URI, use the<code>removeAttributeNS</code>method.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute to remove.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="getAttributeNode" id="ID-217A91B8"><descr><p>Retrieves an attribute node by name.</p><p>To retrieve an attribute node by qualified name and namespace URI, use the<code>getAttributeNodeNS</code>method.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name (<code>nodeName</code>) of the attribute to retrieve.</p></descr></param></parameters><returns type="Attr"><descr><p>The<code>Attr</code>node with the specified name (<code>nodeName</code>) or<code>null</code>if there is no such attribute.</p></descr></returns><raises></raises></method><method name="setAttributeNode" id="ID-887236154"><descr><p>Adds a new attribute node. If an attribute with that name (<code>nodeName</code>) is already present in the element, it is replaced by the new one.</p><p>To add a new attribute node with a qualified name and namespace URI, use the<code>setAttributeNodeNS</code>method.</p></descr><parameters><param name="newAttr" type="Attr" attr="in"><descr><p>The<code>Attr</code>node to add to the attribute list.</p></descr></param></parameters><returns type="Attr"><descr><p>If the<code>newAttr</code>attribute replaces an existing attribute, the replaced<code>Attr</code>node is returned, otherwise<code>null</code>is returned.</p></descr></returns><raises><exception name="DOMException"><descr><p>WRONG_DOCUMENT_ERR: Raised if<code>newAttr</code>was created from a different document than the one that created the element.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>INUSE_ATTRIBUTE_ERR: Raised if<code>newAttr</code>is already an attribute of another<code>Element</code>object. The DOM user must explicitly clone<code>Attr</code>nodes to re-use them in other elements.</p></descr></exception></raises></method><method name="removeAttributeNode" id="ID-D589198"><descr><p>Removes the specified attribute node. If the removed<code>Attr</code>has a default value it is immediately replaced. The replacing attribute has the same namespace URI and local name, as well as the original prefix, when applicable.</p></descr><parameters><param name="oldAttr" type="Attr" attr="in"><descr><p>The<code>Attr</code>node to remove from the attribute list.</p></descr></param></parameters><returns type="Attr"><descr><p>The<code>Attr</code>node that was removed.</p></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NOT_FOUND_ERR: Raised if<code>oldAttr</code>is not an attribute of the element.</p></descr></exception></raises></method><method name="getElementsByTagName" id="ID-1938918D"><descr><p>Returns a<code>NodeList</code>of all<termref def="dt-descendant">descendant</termref><code>Elements</code>with a given tag name, in the order in which they are encountered in a preorder traversal of this<code>Element</code>tree.</p></descr><parameters><param name="tagname" type="DOMString" attr="in"><descr><p>The name of the tag to match on. The special value "*" matches all tags.</p></descr></param></parameters><returns type="NodeList"><descr><p>A list of matching<code>Element</code>nodes.</p></descr></returns><raises></raises></method><method name="getAttributeNS" id="ID-ElGetAttrNS" since="DOM Level 2"><descr><p>Retrieves an attribute value by local name and namespace URI. HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to retrieve.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the attribute to retrieve.</p></descr></param></parameters><returns type="DOMString"><descr><p>The<code>Attr</code>value as a string, or the empty string if that attribute does not have a specified or default value.</p></descr></returns><raises></raises></method><method name="setAttributeNS" id="ID-ElSetAttrNS" since="DOM Level 2"><descr><p>Adds a new attribute. If an attribute with the same local name and namespace URI is already present on the element, its prefix is changed to be the prefix part of the<code>qualifiedName</code>, and its value is changed to be the<code>value</code>parameter. This value is a simple string; it is not parsed as it is being set. So any markup (such as syntax to be recognized as an entity reference) is treated as literal text, and needs to be appropriately escaped by the implementation when it is written out. In order to assign an attribute value that contains entity references, the user must create an<code>Attr</code>node plus any<code>Text</code>and<code>EntityReference</code>nodes, build the appropriate subtree, and use<code>setAttributeNodeNS</code>or<code>setAttributeNode</code>to assign it as the value of an attribute.</p><p>HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to create or alter.</p></descr></param><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The<termref def="dt-qualifiedname">qualified name</termref>of the attribute to create or alter.</p></descr></param><param name="value" type="DOMString" attr="in"><descr><p>The value to set in string form.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is malformed, if the<code>qualifiedName</code>has a prefix and the<code>namespaceURI</code>is<code>null</code>, if the<code>qualifiedName</code>has a prefix that is "xml" and the<code>namespaceURI</code>is different from "", or if the<code>qualifiedName</code>is "xmlns" and the<code>namespaceURI</code>is different from "".</p></descr></exception></raises></method><method name="removeAttributeNS" id="ID-ElRemAtNS" since="DOM Level 2"><descr><p>Removes an attribute by local name and namespace URI. If the removed attribute has a default value it is immediately replaced. The replacing attribute has the same namespace URI and local name, as well as the original prefix.</p><p>HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to remove.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the attribute to remove.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="getAttributeNodeNS" id="ID-ElGetAtNodeNS" since="DOM Level 2"><descr><p>Retrieves an<code>Attr</code>node by local name and namespace URI. HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to retrieve.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the attribute to retrieve.</p></descr></param></parameters><returns type="Attr"><descr><p>The<code>Attr</code>node with the specified attribute local name and namespace URI or<code>null</code>if there is no such attribute.</p></descr></returns><raises></raises></method><method name="setAttributeNodeNS" id="ID-ElSetAtNodeNS" since="DOM Level 2"><descr><p>Adds a new attribute. If an attribute with that local name and that namespace URI is already present in the element, it is replaced by the new one.</p><p>HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="newAttr" type="Attr" attr="in"><descr><p>The<code>Attr</code>node to add to the attribute list.</p></descr></param></parameters><returns type="Attr"><descr><p>If the<code>newAttr</code>attribute replaces an existing attribute with the same<termref def="dt-localname">local name</termref>and<termref def="dt-namespaceURI">namespace URI</termref>, the replaced<code>Attr</code>node is returned, otherwise<code>null</code>is returned.</p></descr></returns><raises><exception name="DOMException"><descr><p>WRONG_DOCUMENT_ERR: Raised if<code>newAttr</code>was created from a different document than the one that created the element.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>INUSE_ATTRIBUTE_ERR: Raised if<code>newAttr</code>is already an attribute of another<code>Element</code>object. The DOM user must explicitly clone<code>Attr</code>nodes to re-use them in other elements.</p></descr></exception></raises></method><method name="getElementsByTagNameNS" id="ID-A6C90942" since="DOM Level 2"><descr><p>Returns a<code>NodeList</code>of all the<termref def="dt-descendant">descendant</termref><code>Elements</code>with a given local name and namespace URI in the order in which they are encountered in a preorder traversal of this<code>Element</code>tree.</p><p>HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the elements to match on. The special value "*" matches all namespaces.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the elements to match on. The special value "*" matches all local names.</p></descr></param></parameters><returns type="NodeList"><descr><p>A new<code>NodeList</code>object containing all the matched<code>Elements</code>.</p></descr></returns><raises></raises></method><method name="hasAttribute" id="ID-ElHasAttr" since="DOM Level 2"><descr><p>Returns<code>true</code>when an attribute with a given name is specified on this element or has a default value,<code>false</code>otherwise.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute to look for.</p></descr></param></parameters><returns type="boolean"><descr><p><code>true</code>if an attribute with the given name is specified on this element or has a default value,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><method name="hasAttributeNS" id="ID-ElHasAttrNS" since="DOM Level 2"><descr><p>Returns<code>true</code>when an attribute with a given local name and namespace URI is specified on this element or has a default value,<code>false</code>otherwise. HTML-only DOM implementations do not need to implement this method.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to look for.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the attribute to look for.</p></descr></param></parameters><returns type="boolean"><descr><p><code>true</code>if an attribute with the given local name and namespace URI is specified or has a default value on this element,<code>false</code>otherwise.</p></descr></returns><raises></raises></method></interface> |
| <interface name="Text" inherits="CharacterData" id="ID-1312295772"><descr><p>The<code>Text</code>interface inherits from<code>CharacterData</code>and represents the textual content (termedin XML) of an<code>Element</code>or<code>Attr</code>. If there is no markup inside an element's content, the text is contained in a single object implementing the<code>Text</code>interface that is the only child of the element. If there is markup, it is parsed into the<termref def="dt-infoitem">information items</termref>(elements, comments, etc.) and<code>Text</code>nodes that form the list of children of the element.</p><p>When a document is first made available via the DOM, there is only one<code>Text</code>node for each block of text. Users may create adjacent<code>Text</code>nodes that represent the contents of a given element without any intervening markup, but should be aware that there is no way to represent the separations between these nodes in XML or HTML, so they will not (in general) persist between DOM editing sessions. The<code>normalize()</code>method on<code>Node</code>merges any such adjacent<code>Text</code>objects into a single node for each block of text.</p></descr><method name="splitText" id="ID-38853C1D"><descr><p>Breaks this node into two nodes at the specified<code>offset</code>, keeping both in the tree as<termref def="dt-sibling">siblings</termref>. After being split, this node will contain all the content up to the<code>offset</code>point. A new node of the same type, which contains all the content at and after the<code>offset</code>point, is returned. If the original node had a parent node, the new node is inserted as the next<termref def="dt-sibling">sibling</termref>of the original node. When the<code>offset</code>is equal to the length of this node, the new node has no data.</p></descr><parameters><param name="offset" type="unsigned long" attr="in"><descr><p>The<termref def="dt-16-bit-unit">16-bit unit</termref>offset at which to split, starting from<code>0</code>.</p></descr></param></parameters><returns type="Text"><descr><p>The new node, of the same type as this node.</p></descr></returns><raises><exception name="DOMException"><descr><p>INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of 16-bit units in<code>data</code>.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method></interface> |
| <interface name="Comment" inherits="CharacterData" id="ID-1728279322"><descr><p>This interface inherits from<code>CharacterData</code>and represents the content of a comment, i.e., all the characters between the starting '<code><!--</code>' and ending '<code>--></code>'. Note that this is the definition of a comment in XML, and, in practice, HTML, although some HTML tools may implement the full SGML comment structure.</p></descr></interface> |
| <interface name="CDATASection" inherits="Text" id="ID-667469212"><descr><p>CDATA sections are used to escape blocks of text containing characters that would otherwise be regarded as markup. The only delimiter that is recognized in a CDATA section is the "]]>" string that ends the CDATA section. CDATA sections cannot be nested. Their primary purpose is for including material such as XML fragments, without needing to escape all the delimiters.</p><p>The<code>DOMString</code>attribute of the<code>Text</code>node holds the text that is contained by the CDATA section. Note that this<emph>may</emph>contain characters that need to be escaped outside of CDATA sections and that, depending on the character encoding ("charset") chosen for serialization, it may be impossible to write out some characters as part of a CDATA section.</p><p>The<code>CDATASection</code>interface inherits from the<code>CharacterData</code>interface through the<code>Text</code>interface. Adjacent<code>CDATASection</code>nodes are not merged by use of the<code>normalize</code>method of the<code>Node</code>interface.</p><note><p>Because no markup is recognized within a<code>CDATASection</code>, character numeric references cannot be used as an escape mechanism when serializing. Therefore, action needs to be taken when serializing a<code>CDATASection</code>with a character encoding where some of the contained characters cannot be represented. Failure to do so would not produce well-formed XML.</p><p>One potential solution in the serialization process is to end the CDATA section before the character, output the character using a character reference or entity reference, and open a new CDATA section for any further characters in the text node. Note, however, that some code conversion libraries at the time of writing do not return an error or exception when a character is missing from the encoding, making the task of ensuring that data is not corrupted on serialization more difficult.</p></note></descr></interface> |
| <interface name="DocumentType" inherits="Node" id="ID-412266927"><descr><p>Each<code>Document</code>has a<code>doctype</code>attribute whose value is either<code>null</code>or a<code>DocumentType</code>object. The<code>DocumentType</code>interface in the DOM Core provides an interface to the list of entities that are defined for the document, and little else because the effect of namespaces and the various XML schema efforts on DTD representation are not clearly understood as of this writing.</p><p>The DOM Level 2 doesn't support editing<code>DocumentType</code>nodes.</p></descr><attribute readonly="yes" name="name" type="DOMString" id="ID-1844763134"><descr><p>The name of DTD; i.e., the name immediately following the<code>DOCTYPE</code>keyword.</p></descr></attribute><attribute readonly="yes" name="entities" type="NamedNodeMap" id="ID-1788794630"><descr><p>A<code>NamedNodeMap</code>containing the general entities, both external and internal, declared in the DTD. Parameter entities are not contained. Duplicates are discarded. For example in:<eg role="code" xml:space="preserve"><!DOCTYPE ex SYSTEM "ex.dtd" [ <!ENTITY foo "foo"> <!ENTITY bar "bar"> <!ENTITY bar "bar2"> <!ENTITY % baz "baz"> ]> <ex/></eg>the interface provides access to<code>foo</code>and the first declaration of<code>bar</code>but not the second declaration of<code>bar</code>or<code>baz</code>. Every node in this map also implements the<code>Entity</code>interface.</p><p>The DOM Level 2 does not support editing entities, therefore<code>entities</code>cannot be altered in any way.</p></descr></attribute><attribute readonly="yes" name="notations" type="NamedNodeMap" id="ID-D46829EF"><descr><p>A<code>NamedNodeMap</code>containing the notations declared in the DTD. Duplicates are discarded. Every node in this map also implements the<code>Notation</code>interface.</p><p>The DOM Level 2 does not support editing notations, therefore<code>notations</code>cannot be altered in any way.</p></descr></attribute><attribute readonly="yes" name="publicId" type="DOMString" id="ID-Core-DocType-publicId" since="DOM Level 2"><descr><p>The public identifier of the external subset.</p></descr></attribute><attribute readonly="yes" name="systemId" type="DOMString" id="ID-Core-DocType-systemId" since="DOM Level 2"><descr><p>The system identifier of the external subset.</p></descr></attribute><attribute readonly="yes" name="internalSubset" type="DOMString" id="ID-Core-DocType-internalSubset" since="DOM Level 2"><descr><p>The internal subset as a string.</p><note><p>The actual content returned depends on how much information is available to the implementation. This may vary depending on various parameters, including the XML processor used to build the document.</p></note></descr></attribute></interface> |
| <interface name="Notation" inherits="Node" id="ID-5431D1B9"><descr><p>This interface represents a notation declared in the DTD. A notation either declares, by name, the format of an unparsed entity (seeof the XML 1.0 specification<bibref ref="XML"/>), or is used for formal declaration of processing instruction targets (seeof the XML 1.0 specification<bibref ref="XML"/>). The<code>nodeName</code>attribute inherited from<code>Node</code>is set to the declared name of the notation.</p><p>The DOM Level 1 does not support editing<code>Notation</code>nodes; they are therefore<termref def="dt-readonly-node">readonly</termref>.</p><p>A<code>Notation</code>node does not have any parent.</p></descr><attribute readonly="yes" name="publicId" type="DOMString" id="ID-54F2B4D0"><descr><p>The public identifier of this notation. If the public identifier was not specified, this is<code>null</code>.</p></descr></attribute><attribute readonly="yes" name="systemId" type="DOMString" id="ID-E8AAB1D0"><descr><p>The system identifier of this notation. If the system identifier was not specified, this is<code>null</code>.</p></descr></attribute></interface> |
| <interface name="Entity" inherits="Node" id="ID-527DCFF2"><descr><p>This interface represents an entity, either parsed or unparsed, in an XML document. Note that this models the entity itself<emph>not</emph>the entity declaration.<code>Entity</code>declaration modeling has been left for a later Level of the DOM specification.</p><p>The<code>nodeName</code>attribute that is inherited from<code>Node</code>contains the name of the entity.</p><p>An XML processor may choose to completely expand entities before the structure model is passed to the DOM; in this case there will be no<code>EntityReference</code>nodes in the document tree.</p><p>XML does not mandate that a non-validating XML processor read and process entity declarations made in the external subset or declared in external parameter entities. This means that parsed entities declared in the external subset need not be expanded by some classes of applications, and that the replacement value of the entity may not be available. When the replacement value is available, the corresponding<code>Entity</code>node's child list represents the structure of that replacement text. Otherwise, the child list is empty.</p><p>The DOM Level 2 does not support editing<code>Entity</code>nodes; if a user wants to make changes to the contents of an<code>Entity</code>, every related<code>EntityReference</code>node has to be replaced in the structure model by a clone of the<code>Entity</code>'s contents, and then the desired changes must be made to each of those clones instead.<code>Entity</code>nodes and all their<termref def="dt-descendant">descendants</termref>are<termref def="dt-readonly-node">readonly</termref>.</p><p>An<code>Entity</code>node does not have any parent.</p><note><p>If the entity contains an unbound<termref def="dt-namespaceprefix">namespace prefix</termref>, the<code>namespaceURI</code>of the corresponding node in the<code>Entity</code>node subtree is<code>null</code>. The same is true for<code>EntityReference</code>nodes that refer to this entity, when they are created using the<code>createEntityReference</code>method of the<code>Document</code>interface. The DOM Level 2 does not support any mechanism to resolve namespace prefixes.</p></note></descr><attribute readonly="yes" name="publicId" type="DOMString" id="ID-D7303025"><descr><p>The public identifier associated with the entity, if specified. If the public identifier was not specified, this is<code>null</code>.</p></descr></attribute><attribute readonly="yes" name="systemId" type="DOMString" id="ID-D7C29F3E"><descr><p>The system identifier associated with the entity, if specified. If the system identifier was not specified, this is<code>null</code>.</p></descr></attribute><attribute readonly="yes" name="notationName" type="DOMString" id="ID-6ABAEB38"><descr><p>For unparsed entities, the name of the notation for the entity. For parsed entities, this is<code>null</code>.</p></descr></attribute></interface> |
| <interface name="EntityReference" inherits="Node" id="ID-11C98490"><descr><p><code>EntityReference</code>objects may be inserted into the structure model when an entity reference is in the source document, or when the user wishes to insert an entity reference. Note that character references and references to predefined entities are considered to be expanded by the HTML or XML processor so that characters are represented by their Unicode equivalent rather than by an entity reference. Moreover, the XML processor may completely expand references to entities while building the structure model, instead of providing<code>EntityReference</code>objects. If it does provide such objects, then for a given<code>EntityReference</code>node, it may be that there is no<code>Entity</code>node representing the referenced entity. If such an<code>Entity</code>exists, then the subtree of the<code>EntityReference</code>node is in general a copy of the<code>Entity</code>node subtree. However, this may not be true when an entity contains an unbound<termref def="dt-namespaceprefix">namespace prefix</termref>. In such a case, because the namespace prefix resolution depends on where the entity reference is, the<termref def="dt-descendant">descendants</termref>of the<code>EntityReference</code>node may be bound to different<termref def="dt-namespaceURI">namespace URIs</termref>.</p><p>As for<code>Entity</code>nodes,<code>EntityReference</code>nodes and all their<termref def="dt-descendant">descendants</termref>are<termref def="dt-readonly-node">readonly</termref>.</p></descr></interface> |
| <interface name="ProcessingInstruction" inherits="Node" id="ID-1004215813"><descr><p>The<code>ProcessingInstruction</code>interface represents a "processing instruction", used in XML as a way to keep processor-specific information in the text of the document.</p></descr><attribute readonly="yes" type="DOMString" name="target" id="ID-1478689192"><descr><p>The target of this processing instruction. XML defines this as being the first<termref def="dt-token">token</termref>following the markup that begins the processing instruction.</p></descr></attribute><attribute type="DOMString" name="data" id="ID-837822393" readonly="no"><descr><p>The content of this processing instruction. This is from the first non white space character after the target to the character immediately preceding the<code>?></code>.</p></descr><setraises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p></descr></exception></setraises></attribute></interface> |
| <interface id="i18n-methods-StringExtend" name="StringExtend"><descr><p>Extensions to a language's native String class or interface</p></descr><method id="i18n-methods-StringExtend-findOffset16" name="findOffset16"><descr><p>Returns the UTF-16 offset that corresponds to a UTF-32 offset. Used for random access.</p><note><p>You can always round-trip from a UTF-32 offset to a UTF-16 offset and back. You can round-trip from a UTF-16 offset to a UTF-32 offset and back if and only if the offset16 is not in the middle of a surrogate pair. Unmatched surrogates count as a single UTF-16 value.</p></note></descr><parameters><param name="offset32" type="int" attr="in"><descr><p>UTF-32 offset.</p></descr></param></parameters><returns type="int"><descr><p>UTF-16 offset</p></descr></returns><raises><exception name="StringIndexOutOfBoundsException"><descr><p>if<code>offset32</code>is out of bounds.</p></descr></exception></raises></method><method id="i18n-methods-StringExtend-findOffset32" name="findOffset32"><descr><p>Returns the UTF-32 offset corresponding to a UTF-16 offset. Used for random access. To find the UTF-32 length of a string, use:<eg xml:space="preserve">len32 = findOffset32(source, source.length());</eg></p><note><p>If the UTF-16 offset is into the middle of a surrogate pair, then the UTF-32 offset of the<emph>end</emph>of the pair is returned; that is, the index of the char after the end of the pair. You can always round-trip from a UTF-32 offset to a UTF-16 offset and back. You can round-trip from a UTF-16 offset to a UTF-32 offset and back if and only if the offset16 is not in the middle of a surrogate pair. Unmatched surrogates count as a single UTF-16 value.</p></note></descr><parameters><param attr="in" type="int" name="offset16"><descr><p>UTF-16 offset</p></descr></param></parameters><returns type="int"><descr><p>UTF-32 offset</p></descr></returns><raises><exception name="StringIndexOutOfBoundsException"><descr><p>if offset16 is out of bounds.</p></descr></exception></raises></method></interface> |
| </library> |
| /contrib/network/netsurf/libdom/test/dom2-events-interface.xml |
|---|
| 0,0 → 1,588 |
| <?xml version="1.0"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Document |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!--This file is an extract of interface definitions from Document Object Model (DOM) Level 2 Events Specification--> |
| <library> |
| <interface name="EventTarget" id="Events-EventTarget" since="DOM Level 2"> |
| <descr> |
| <p>The<code>EventTarget</code>interface is implemented by all<code>Nodes</code>in an implementation which supports the DOM Event Model. Therefore, this interface can be obtained by using binding-specific casting methods on an instance of the<code>Node</code>interface. The interface allows registration and removal of<code>EventListeners</code>on an<code>EventTarget</code>and dispatch of events to that<code>EventTarget</code>.</p> |
| </descr> |
| <method name="addEventListener" id="Events-EventTarget-addEventListener"> |
| <descr> |
| <p>This method allows the registration of event listeners on the event target. If an<code>EventListener</code>is added to an<code>EventTarget</code>while it is processing an event, it will not be triggered by the current actions but may be triggered during a later stage of event flow, such as the bubbling phase.</p> |
| <p>If multiple identical<code>EventListener</code>s are registered on the same<code>EventTarget</code>with the same parameters the duplicate instances are discarded. They do not cause the<code>EventListener</code>to be called twice and since they are discarded they do not need to be removed with the<code>removeEventListener</code>method.</p> |
| </descr> |
| <parameters> |
| <param name="type" type="DOMString" attr="in"> |
| <descr> |
| <p>The event type for which the user is registering</p> |
| </descr> |
| </param> |
| <param name="listener" type="EventListener" attr="in"> |
| <descr> |
| <p>The<code>listener</code>parameter takes an interface implemented by the user which contains the methods to be called when the event occurs.</p> |
| </descr> |
| </param> |
| <param name="useCapture" type="boolean" attr="in"> |
| <descr> |
| <p>If true,<code>useCapture</code>indicates that the user wishes to initiate capture. After initiating capture, all events of the specified type will be dispatched to the registered<code>EventListener</code>before being dispatched to any<code>EventTargets</code>beneath them in the tree. Events which are bubbling upward through the tree will not trigger an<code>EventListener</code>designated to use capture.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="removeEventListener" id="Events-EventTarget-removeEventListener"> |
| <descr> |
| <p>This method allows the removal of event listeners from the event target. If an<code>EventListener</code>is removed from an<code>EventTarget</code>while it is processing an event, it will not be triggered by the current actions.<code>EventListener</code>s can never be invoked after being removed.</p> |
| <p>Calling<code>removeEventListener</code>with arguments which do not identify any currently registered<code>EventListener</code>on the<code>EventTarget</code>has no effect.</p> |
| </descr> |
| <parameters> |
| <param name="type" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the event type of the<code>EventListener</code>being removed.</p> |
| </descr> |
| </param> |
| <param name="listener" type="EventListener" attr="in"> |
| <descr> |
| <p>The<code>EventListener</code>parameter indicates the<code>EventListener</code>to be removed.</p> |
| </descr> |
| </param> |
| <param name="useCapture" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether the<code>EventListener</code>being removed was registered as a capturing listener or not. If a listener was registered twice, one with capture and one without, each must be removed separately. Removal of a capturing listener does not affect a non-capturing version of the same listener, and vice versa.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="dispatchEvent" id="Events-EventTarget-dispatchEvent"> |
| <descr> |
| <p>This method allows the dispatch of events into the implementations event model. Events dispatched in this manner will have the same capturing and bubbling behavior as events dispatched directly by the implementation. The target of the event is the<code>EventTarget</code>on which<code>dispatchEvent</code>is called.</p> |
| </descr> |
| <parameters> |
| <param name="evt" type="Event" attr="in"> |
| <descr> |
| <p>Specifies the event type, behavior, and contextual information to be used in processing the event.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="boolean"> |
| <descr> |
| <p>The return value of<code>dispatchEvent</code>indicates whether any of the listeners which handled the event called<code>preventDefault</code>. If<code>preventDefault</code>was called the value is false, else the value is true.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="EventException"> |
| <descr> |
| <p>UNSPECIFIED_EVENT_TYPE_ERR: Raised if the<code>Event</code>'s type was not specified by initializing the event before<code>dispatchEvent</code>was called. Specification of the<code>Event</code>'s type as<code>null</code>or an empty string will also trigger this exception.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| </interface> |
| <interface id="Events-EventListener" name="EventListener" since="DOM Level 2"> |
| <descr> |
| <p>The<code>EventListener</code>interface is the primary method for handling events. Users implement the<code>EventListener</code>interface and register their listener on an<code>EventTarget</code>using the<code>AddEventListener</code>method. The users should also remove their<code>EventListener</code>from its<code>EventTarget</code>after they have completed using the listener.</p> |
| <p>When a<code>Node</code>is copied using the<code>cloneNode</code>method the<code>EventListener</code>s attached to the source<code>Node</code>are not attached to the copied<code>Node</code>. If the user wishes the same<code>EventListener</code>s to be added to the newly created copy the user must add them manually.</p> |
| </descr> |
| <method name="handleEvent" id="Events-EventListener-handleEvent"> |
| <descr> |
| <p>This method is called whenever an event occurs of the type for which the<code>EventListener</code>interface was registered.</p> |
| </descr> |
| <parameters> |
| <param name="evt" type="Event" attr="in"> |
| <descr> |
| <p>The<code>Event</code>contains contextual information about the event. It also contains the<code>stopPropagation</code>and<code>preventDefault</code>methods which are used in determining the event's flow and default action.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="Event" id="Events-Event" since="DOM Level 2"> |
| <descr> |
| <p>The<code>Event</code>interface is used to provide contextual information about an event to the handler processing the event. An object which implements the<code>Event</code>interface is generally passed as the first parameter to an event handler. More specific context information is passed to event handlers by deriving additional interfaces from<code>Event</code>which contain information directly relating to the type of event they accompany. These derived interfaces are also implemented by the object passed to the event listener.</p> |
| </descr> |
| <group id="Events-Event-eventPhaseType" name="PhaseType"> |
| <descr> |
| <p>An integer indicating which phase of event flow is being processed.</p> |
| </descr> |
| <constant name="CAPTURING_PHASE" type="unsigned short" value="1"> |
| <descr> |
| <p>The current event phase is the capturing phase.</p> |
| </descr> |
| </constant> |
| <constant name="AT_TARGET" type="unsigned short" value="2"> |
| <descr> |
| <p>The event is currently being evaluated at the target<code>EventTarget</code>.</p> |
| </descr> |
| </constant> |
| <constant name="BUBBLING_PHASE" type="unsigned short" value="3"> |
| <descr> |
| <p>The current event phase is the bubbling phase.</p> |
| </descr> |
| </constant> |
| </group> |
| <attribute type="DOMString" name="type" readonly="yes" id="Events-Event-type"> |
| <descr> |
| <p>The name of the event (case-insensitive). The name must be an<termref def="dt-XML-name">XML name</termref>.</p> |
| </descr> |
| </attribute> |
| <attribute type="EventTarget" name="target" readonly="yes" id="Events-Event-target"> |
| <descr> |
| <p>Used to indicate the<code>EventTarget</code>to which the event was originally dispatched.</p> |
| </descr> |
| </attribute> |
| <attribute type="EventTarget" name="currentTarget" readonly="yes" id="Events-Event-currentTarget"> |
| <descr> |
| <p>Used to indicate the<code>EventTarget</code>whose<code>EventListeners</code>are currently being processed. This is particularly useful during capturing and bubbling.</p> |
| </descr> |
| </attribute> |
| <attribute type="unsigned short" name="eventPhase" readonly="yes" id="Events-Event-eventPhase"> |
| <descr> |
| <p>Used to indicate which phase of event flow is currently being evaluated.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="bubbles" readonly="yes" id="Events-Event-canBubble"> |
| <descr> |
| <p>Used to indicate whether or not an event is a bubbling event. If the event can bubble the value is true, else the value is false.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="cancelable" readonly="yes" id="Events-Event-canCancel"> |
| <descr> |
| <p>Used to indicate whether or not an event can have its default action prevented. If the default action can be prevented the value is true, else the value is false.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMTimeStamp" name="timeStamp" readonly="yes" id="Events-Event-timeStamp"> |
| <descr> |
| <p>Used to specify the time (in milliseconds relative to the epoch) at which the event was created. Due to the fact that some systems may not provide this information the value of<code>timeStamp</code>may be not available for all events. When not available, a value of 0 will be returned. Examples of epoch time are the time of the system start or 0:0:0 UTC 1st January 1970.</p> |
| </descr> |
| </attribute> |
| <method name="stopPropagation" id="Events-Event-stopPropagation"> |
| <descr> |
| <p>The<code>stopPropagation</code>method is used prevent further propagation of an event during event flow. If this method is called by any<code>EventListener</code>the event will cease propagating through the tree. The event will complete dispatch to all listeners on the current<code>EventTarget</code>before event flow stops. This method may be used during any stage of event flow.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="preventDefault" id="Events-Event-preventDefault"> |
| <descr> |
| <p>If an event is cancelable, the<code>preventDefault</code>method is used to signify that the event is to be canceled, meaning any default action normally taken by the implementation as a result of the event will not occur. If, during any stage of event flow, the<code>preventDefault</code>method is called the event is canceled. Any default action associated with the event will not occur. Calling this method for a non-cancelable event has no effect. Once<code>preventDefault</code>has been called it will remain in effect throughout the remainder of the event's propagation. This method may be used during any stage of event flow.</p> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="initEvent" id="Events-Event-initEvent"> |
| <descr> |
| <p>The<code>initEvent</code>method is used to initialize the value of an<code>Event</code>created through the<code>DocumentEvent</code>interface. This method may only be called before the<code>Event</code>has been dispatched via the<code>dispatchEvent</code>method, though it may be called multiple times during that phase if necessary. If called multiple times the final invocation takes precedence. If called from a subclass of<code>Event</code>interface only the values specified in the<code>initEvent</code>method are modified, all other attributes are left unchanged.</p> |
| </descr> |
| <parameters> |
| <param name="eventTypeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the event type. This type may be any event type currently defined in this specification or a new event type.. The string must be an<termref def="dt-XML-name">XML name</termref>.</p> |
| <p>Any new event type must not begin with any upper, lower, or mixed case version of the string "DOM". This prefix is reserved for future DOM event sets. It is also strongly recommended that third parties adding their own events use their own prefix to avoid confusion and lessen the probability of conflicts with other new events.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not the event can bubble.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not the event's default action can be prevented.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <exception id="Events-EventException" name="EventException" since="DOM Level 2"> |
| <descr> |
| <p>Event operations may throw an<code>EventException</code>as specified in their method descriptions.</p> |
| </descr> |
| <component id="Events-EventException-code" name="code"> |
| <typename>unsigned short</typename> |
| </component> |
| </exception> |
| <group id="Events-EventException-EventExceptionCode" name="EventExceptionCode" since="DOM Level 2"> |
| <descr> |
| <p>An integer indicating the type of error generated.</p> |
| </descr> |
| <constant name="UNSPECIFIED_EVENT_TYPE_ERR" type="unsigned short" value="0"> |
| <descr> |
| <p>If the<code>Event</code>'s type was not specified by initializing the event before the method was called. Specification of the Event's type as<code>null</code>or an empty string will also trigger this exception.</p> |
| </descr> |
| </constant> |
| </group> |
| <interface name="DocumentEvent" id="Events-DocumentEvent" since="DOM Level 2"> |
| <descr> |
| <p>The<code>DocumentEvent</code>interface provides a mechanism by which the user can create an Event of a type supported by the implementation. It is expected that the<code>DocumentEvent</code>interface will be implemented on the same object which implements the<code>Document</code>interface in an implementation which supports the Event model.</p> |
| </descr> |
| <method name="createEvent" id="Events-DocumentEvent-createEvent"> |
| <descr> |
| <p/> |
| </descr> |
| <parameters> |
| <param name="eventType" type="DOMString" attr="in"> |
| <descr> |
| <p>The<code>eventType</code>parameter specifies the type of<code>Event</code>interface to be created. If the<code>Event</code>interface specified is supported by the implementation this method will return a new<code>Event</code>of the interface type requested. If the<code>Event</code>is to be dispatched via the<code>dispatchEvent</code>method the appropriate event init method must be called after creation in order to initialize the<code>Event</code>'s values. As an example, a user wishing to synthesize some kind of<code>UIEvent</code>would call<code>createEvent</code>with the parameter "UIEvents". The<code>initUIEvent</code>method could then be called on the newly created<code>UIEvent</code>to set the specific type of UIEvent to be dispatched and set its context information.</p> |
| <p>The<code>createEvent</code>method is used in creating<code>Event</code>s when it is either inconvenient or unnecessary for the user to create an<code>Event</code>themselves. In cases where the implementation provided<code>Event</code>is insufficient, users may supply their own<code>Event</code>implementations for use with the<code>dispatchEvent</code>method.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Event"> |
| <descr> |
| <p>The newly created<code>Event</code></p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NOT_SUPPORTED_ERR: Raised if the implementation does not support the type of<code>Event</code>interface requested</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| </interface> |
| <interface name="UIEvent" inherits="Event" id="Events-UIEvent" since="DOM Level 2"> |
| <descr> |
| <p>The<code>UIEvent</code>interface provides specific contextual information associated with User Interface events.</p> |
| </descr> |
| <attribute type="views::AbstractView" name="view" readonly="yes" id="Events-UIEvent-view"> |
| <descr> |
| <p>The<code>view</code>attribute identifies the<code>AbstractView</code>from which the event was generated.</p> |
| </descr> |
| </attribute> |
| <attribute id="Events-UIEvent-detail" name="detail" type="long" readonly="yes"> |
| <descr> |
| <p>Specifies some detail information about the<code>Event</code>, depending on the type of event.</p> |
| </descr> |
| </attribute> |
| <method name="initUIEvent" id="Events-Event-initUIEvent"> |
| <descr> |
| <p>The<code>initUIEvent</code>method is used to initialize the value of a<code>UIEvent</code>created through the<code>DocumentEvent</code>interface. This method may only be called before the<code>UIEvent</code>has been dispatched via the<code>dispatchEvent</code>method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence.</p> |
| </descr> |
| <parameters> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the event type.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not the event can bubble.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not the event's default action can be prevented.</p> |
| </descr> |
| </param> |
| <param name="viewArg" type="views::AbstractView" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s<code>AbstractView</code>.</p> |
| </descr> |
| </param> |
| <param name="detailArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s detail.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="MouseEvent" inherits="UIEvent" id="Events-MouseEvent" since="DOM Level 2"> |
| <descr> |
| <p>The<code>MouseEvent</code>interface provides specific contextual information associated with Mouse events.</p> |
| <p>The<code>detail</code>attribute inherited from<code>UIEvent</code>indicates the number of times a mouse button has been pressed and released over the same screen location during a user action. The attribute value is 1 when the user begins this action and increments by 1 for each full sequence of pressing and releasing. If the user moves the mouse between the mousedown and mouseup the value will be set to 0, indicating that no click is occurring.</p> |
| <p>In the case of nested elements mouse events are always targeted at the most deeply nested element. Ancestors of the targeted element may use bubbling to obtain notification of mouse events which occur within its descendent elements.</p> |
| </descr> |
| <attribute type="long" name="screenX" readonly="yes" id="Events-MouseEvent-screenX"> |
| <descr> |
| <p>The horizontal coordinate at which the event occurred relative to the origin of the screen coordinate system.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="screenY" readonly="yes" id="Events-MouseEvent-screenY"> |
| <descr> |
| <p>The vertical coordinate at which the event occurred relative to the origin of the screen coordinate system.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="clientX" readonly="yes" id="Events-MouseEvent-clientX"> |
| <descr> |
| <p>The horizontal coordinate at which the event occurred relative to the DOM implementation's client area.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="clientY" readonly="yes" id="Events-MouseEvent-clientY"> |
| <descr> |
| <p>The vertical coordinate at which the event occurred relative to the DOM implementation's client area.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="ctrlKey" readonly="yes" id="Events-MouseEvent-ctrlKey"> |
| <descr> |
| <p>Used to indicate whether the 'ctrl' key was depressed during the firing of the event.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="shiftKey" readonly="yes" id="Events-MouseEvent-shiftKey"> |
| <descr> |
| <p>Used to indicate whether the 'shift' key was depressed during the firing of the event.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="altKey" readonly="yes" id="Events-MouseEvent-altKey"> |
| <descr> |
| <p>Used to indicate whether the 'alt' key was depressed during the firing of the event. On some platforms this key may map to an alternative key name.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="metaKey" readonly="yes" id="Events-MouseEvent-metaKey"> |
| <descr> |
| <p>Used to indicate whether the 'meta' key was depressed during the firing of the event. On some platforms this key may map to an alternative key name.</p> |
| </descr> |
| </attribute> |
| <attribute type="unsigned short" name="button" readonly="yes" id="Events-MouseEvent-button"> |
| <descr> |
| <p>During mouse events caused by the depression or release of a mouse button,<code>button</code>is used to indicate which mouse button changed state. The values for<code>button</code>range from zero to indicate the left button of the mouse, one to indicate the middle button if present, and two to indicate the right button. For mice configured for left handed use in which the button actions are reversed the values are instead read from right to left.</p> |
| </descr> |
| </attribute> |
| <attribute type="EventTarget" name="relatedTarget" readonly="yes" id="Events-MouseEvent-relatedTarget"> |
| <descr> |
| <p>Used to identify a secondary<code>EventTarget</code>related to a UI event. Currently this attribute is used with the mouseover event to indicate the<code>EventTarget</code>which the pointing device exited and with the mouseout event to indicate the<code>EventTarget</code>which the pointing device entered.</p> |
| </descr> |
| </attribute> |
| <method name="initMouseEvent" id="Events-Event-initMouseEvent"> |
| <descr> |
| <p>The<code>initMouseEvent</code>method is used to initialize the value of a<code>MouseEvent</code>created through the<code>DocumentEvent</code>interface. This method may only be called before the<code>MouseEvent</code>has been dispatched via the<code>dispatchEvent</code>method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence.</p> |
| </descr> |
| <parameters> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the event type.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not the event can bubble.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not the event's default action can be prevented.</p> |
| </descr> |
| </param> |
| <param name="viewArg" type="views::AbstractView" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s<code>AbstractView</code>.</p> |
| </descr> |
| </param> |
| <param name="detailArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s mouse click count.</p> |
| </descr> |
| </param> |
| <param name="screenXArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s screen x coordinate</p> |
| </descr> |
| </param> |
| <param name="screenYArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s screen y coordinate</p> |
| </descr> |
| </param> |
| <param name="clientXArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s client x coordinate</p> |
| </descr> |
| </param> |
| <param name="clientYArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s client y coordinate</p> |
| </descr> |
| </param> |
| <param name="ctrlKeyArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not control key was depressed during the<code>Event</code>.</p> |
| </descr> |
| </param> |
| <param name="altKeyArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not alt key was depressed during the<code>Event</code>.</p> |
| </descr> |
| </param> |
| <param name="shiftKeyArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not shift key was depressed during the<code>Event</code>.</p> |
| </descr> |
| </param> |
| <param name="metaKeyArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not meta key was depressed during the<code>Event</code>.</p> |
| </descr> |
| </param> |
| <param name="buttonArg" type="unsigned short" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s mouse button.</p> |
| </descr> |
| </param> |
| <param name="relatedTargetArg" type="EventTarget" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s related<code>EventTarget</code>.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="MutationEvent" inherits="Event" id="Events-MutationEvent" since="DOM Level 2"> |
| <descr> |
| <p>The<code>MutationEvent</code>interface provides specific contextual information associated with Mutation events.</p> |
| </descr> |
| <group id="Events-MutationEvent-attrChangeType" name="attrChangeType"> |
| <descr> |
| <p>An integer indicating in which way the<code>Attr</code>was changed.</p> |
| </descr> |
| <constant name="MODIFICATION" type="unsigned short" value="1"> |
| <descr> |
| <p>The<code>Attr</code>was modified in place.</p> |
| </descr> |
| </constant> |
| <constant name="ADDITION" type="unsigned short" value="2"> |
| <descr> |
| <p>The<code>Attr</code>was just added.</p> |
| </descr> |
| </constant> |
| <constant name="REMOVAL" type="unsigned short" value="3"> |
| <descr> |
| <p>The<code>Attr</code>was just removed.</p> |
| </descr> |
| </constant> |
| </group> |
| <attribute type="Node" name="relatedNode" readonly="yes" id="Events-MutationEvent-relatedNode"> |
| <descr> |
| <p><code>relatedNode</code>is used to identify a secondary node related to a mutation event. For example, if a mutation event is dispatched to a node indicating that its parent has changed, the<code>relatedNode</code>is the changed parent. If an event is instead dispatched to a subtree indicating a node was changed within it, the<code>relatedNode</code>is the changed node. In the case of the DOMAttrModified event it indicates the<code>Attr</code>node which was modified, added, or removed.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="prevValue" readonly="yes" id="Events-MutationEvent-prevValue"> |
| <descr> |
| <p><code>prevValue</code>indicates the previous value of the<code>Attr</code>node in DOMAttrModified events, and of the<code>CharacterData</code>node in DOMCharDataModified events.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="newValue" readonly="yes" id="Events-MutationEvent-newValue"> |
| <descr> |
| <p><code>newValue</code>indicates the new value of the<code>Attr</code>node in DOMAttrModified events, and of the<code>CharacterData</code>node in DOMCharDataModified events.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="attrName" readonly="yes" id="Events-MutationEvent-attrName"> |
| <descr> |
| <p><code>attrName</code>indicates the name of the changed<code>Attr</code>node in a DOMAttrModified event.</p> |
| </descr> |
| </attribute> |
| <attribute type="unsigned short" name="attrChange" readonly="yes" id="Events-MutationEvent-attrChange"> |
| <descr> |
| <p><code>attrChange</code>indicates the type of change which triggered the DOMAttrModified event. The values can be<code>MODIFICATION</code>,<code>ADDITION</code>, or<code>REMOVAL</code>.</p> |
| </descr> |
| </attribute> |
| <method name="initMutationEvent" id="Events-Event-initMutationEvent"> |
| <descr> |
| <p>The<code>initMutationEvent</code>method is used to initialize the value of a<code>MutationEvent</code>created through the<code>DocumentEvent</code>interface. This method may only be called before the<code>MutationEvent</code>has been dispatched via the<code>dispatchEvent</code>method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence.</p> |
| </descr> |
| <parameters> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the event type.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not the event can bubble.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether or not the event's default action can be prevented.</p> |
| </descr> |
| </param> |
| <param name="relatedNodeArg" type="Node" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s related Node.</p> |
| </descr> |
| </param> |
| <param name="prevValueArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s<code>prevValue</code>attribute. This value may be null.</p> |
| </descr> |
| </param> |
| <param name="newValueArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s<code>newValue</code>attribute. This value may be null.</p> |
| </descr> |
| </param> |
| <param name="attrNameArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s<code>attrName</code>attribute. This value may be null.</p> |
| </descr> |
| </param> |
| <param name="attrChangeArg" type="unsigned short" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event</code>'s<code>attrChange</code>attribute</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| </library> |
| /contrib/network/netsurf/libdom/test/dom3-core-interface.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Document |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!--This file is an extract of interface definitions from Document Object Model (DOM) Level 3 Core Specification--> |
| <library> |
| <exception name="DOMException" id="ID-17189187"><descr><p>DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impossible to perform (either for logical reasons, because data is lost, or because the implementation has become unstable). In general, DOM methods return specific error values in ordinary processing situations, such as out-of-bound errors when using<code>NodeList</code>.</p><p>Implementations should raise other exceptions under other circumstances. For example, implementations should raise an implementation-dependent exception if a<code>null</code>argument is passed when<code>null</code>was not expected.</p><p>Some languages and object systems do not support the concept of exceptions. For such systems, error conditions may be indicated using native error reporting mechanisms. For some bindings, for example, methods may return error codes similar to those listed in the corresponding method descriptions.</p></descr><component id="ID-146F692A" name="code"><typename>unsigned short</typename></component></exception> |
| <group id="ID-258A00AF" name="ExceptionCode"><descr><p>An integer indicating the type of error generated.</p><note><p>Other numeric codes are reserved for W3C for possible future use.</p></note></descr><constant id="DOMException-INDEX_SIZE_ERR" name="INDEX_SIZE_ERR" type="unsigned short" value="1"><descr><p>If index or size is negative, or greater than the allowed value.</p></descr></constant><constant id="DOMException-DOMSTRING_SIZE_ERR" name="DOMSTRING_SIZE_ERR" type="unsigned short" value="2"><descr><p>If the specified range of text does not fit into a<code>DOMString</code>.</p></descr></constant><constant id="DOMException-HIERARCHY_REQUEST_ERR" name="HIERARCHY_REQUEST_ERR" type="unsigned short" value="3"><descr><p>If any<code>Node</code>is inserted somewhere it doesn't belong.</p></descr></constant><constant id="DOMException-WRONG_DOCUMENT_ERR" name="WRONG_DOCUMENT_ERR" type="unsigned short" value="4"><descr><p>If a<code>Node</code>is used in a different document than the one that created it (that doesn't support it).</p></descr></constant><constant id="DOMException-INVALID_CHARACTER_ERR" name="INVALID_CHARACTER_ERR" type="unsigned short" value="5"><descr><p>If an invalid or illegal character is specified, such as in an XML name.</p></descr></constant><constant id="DOMException-NO_DATA_ALLOWED_ERR" name="NO_DATA_ALLOWED_ERR" type="unsigned short" value="6"><descr><p>If data is specified for a<code>Node</code>which does not support data.</p></descr></constant><constant id="DOMException-NO_MODIFICATION_ALLOWED_ERR" name="NO_MODIFICATION_ALLOWED_ERR" type="unsigned short" value="7"><descr><p>If an attempt is made to modify an object where modifications are not allowed.</p></descr></constant><constant id="DOMException-NOT_FOUND_ERR" name="NOT_FOUND_ERR" type="unsigned short" value="8"><descr><p>If an attempt is made to reference a<code>Node</code>in a context where it does not exist.</p></descr></constant><constant id="DOMException-NOT_SUPPORTED_ERR" name="NOT_SUPPORTED_ERR" type="unsigned short" value="9"><descr><p>If the implementation does not support the requested type of object or operation.</p></descr></constant><constant id="DOMException-INUSE_ATTRIBUTE_ERR" name="INUSE_ATTRIBUTE_ERR" type="unsigned short" value="10"><descr><p>If an attempt is made to add an attribute that is already in use elsewhere.</p></descr></constant><constant id="DOMException-INVALID_STATE_ERR" name="INVALID_STATE_ERR" type="unsigned short" value="11" since="DOM Level 2"><descr><p>If an attempt is made to use an object that is not, or is no longer, usable.</p></descr></constant><constant id="DOMException-SYNTAX_ERR" name="SYNTAX_ERR" type="unsigned short" value="12" since="DOM Level 2"><descr><p>If an invalid or illegal string is specified.</p></descr></constant><constant id="DOMException-INVALID_MODIFICATION_ERR" name="INVALID_MODIFICATION_ERR" type="unsigned short" value="13" since="DOM Level 2"><descr><p>If an attempt is made to modify the type of the underlying object.</p></descr></constant><constant id="DOMException-NAMESPACE_ERR" name="NAMESPACE_ERR" type="unsigned short" value="14" since="DOM Level 2"><descr><p>If an attempt is made to create or change an object in a way which is incorrect with regard to namespaces.</p></descr></constant><constant id="DOMException-INVALID_ACCESS_ERR" name="INVALID_ACCESS_ERR" type="unsigned short" value="15" since="DOM Level 2"><descr><p>If a parameter or an operation is not supported by the underlying object.</p></descr></constant><constant id="DOMException-VALIDATION_ERR" name="VALIDATION_ERR" type="unsigned short" value="16" since="DOM Level 3"><descr><p>If a call to a method such as<code>insertBefore</code>or<code>removeChild</code>would make the<code>Node</code>invalid with respect to<termref def="dt-partially-valid">"partial validity"</termref>, this exception would be raised and the operation would not be done. This code is used in<bibref role="informative" ref="DOMVal"/>. Refer to this specification for further information.</p></descr></constant><constant id="DOMException-TYPE_MISMATCH_ERR" name="TYPE_MISMATCH_ERR" type="unsigned short" value="17" since="DOM Level 3"><descr><p>If the type of an object is incompatible with the expected type of the parameter associated to the object.</p></descr></constant></group> |
| <interface name="DOMStringList" id="DOMStringList" since="DOM Level 3"><descr><p>The<code>DOMStringList</code>interface provides the abstraction of an ordered collection of<code>DOMString</code>values, without defining or constraining how this collection is implemented. The items in the<code>DOMStringList</code>are accessible via an integral index, starting from 0.</p></descr><method name="item" id="DOMStringList-item"><descr><p>Returns the<code>index</code>th item in the collection. If<code>index</code>is greater than or equal to the number of<code>DOMString</code>s in the list, this returns<code>null</code>.</p></descr><parameters><param name="index" type="unsigned long" attr="in"><descr><p>Index into the collection.</p></descr></param></parameters><returns type="DOMString"><descr><p>The<code>DOMString</code>at the<code>index</code>th position in the<code>DOMStringList</code>, or<code>null</code>if that is not a valid index.</p></descr></returns><raises></raises></method><attribute type="unsigned long" readonly="yes" name="length" id="DOMStringList-length"><descr><p>The number of<code>DOMString</code>s in the list. The range of valid child node indices is 0 to<code>length-1</code>inclusive.</p></descr></attribute><method name="contains" id="DOMStringList-contains"><descr><p>Test if a string is part of this<code>DOMStringList</code>.</p></descr><parameters><param name="str" type="DOMString" attr="in"><descr><p>The string to look for.</p></descr></param></parameters><returns type="boolean"><descr><p><code>true</code>if the string has been found,<code>false</code>otherwise.</p></descr></returns><raises></raises></method></interface> |
| <interface name="NameList" id="NameList" since="DOM Level 3"><descr><p>The<code>NameList</code>interface provides the abstraction of an ordered collection of parallel pairs of name and namespace values (which could be null values), without defining or constraining how this collection is implemented. The items in the<code>NameList</code>are accessible via an integral index, starting from 0.</p></descr><method name="getName" id="NameList-getName"><descr><p>Returns the<code>index</code>th name item in the collection.</p></descr><parameters><param name="index" type="unsigned long" attr="in"><descr><p>Index into the collection.</p></descr></param></parameters><returns type="DOMString"><descr><p>The name at the<code>index</code>th position in the<code>NameList</code>, or<code>null</code>if there is no name for the specified index or if the index is out of range.</p></descr></returns><raises></raises></method><method name="getNamespaceURI" id="NameList-getNamespaceURI"><descr><p>Returns the<code>index</code>th namespaceURI item in the collection.</p></descr><parameters><param name="index" type="unsigned long" attr="in"><descr><p>Index into the collection.</p></descr></param></parameters><returns type="DOMString"><descr><p>The namespace URI at the<code>index</code>th position in the<code>NameList</code>, or<code>null</code>if there is no name for the specified index or if the index is out of range.</p></descr></returns><raises></raises></method><attribute type="unsigned long" readonly="yes" name="length" id="NameList-length"><descr><p>The number of pairs (name and namespaceURI) in the list. The range of valid child node indices is 0 to<code>length-1</code>inclusive.</p></descr></attribute><method name="contains" id="NameList-contains"><descr><p>Test if a name is part of this<code>NameList</code>.</p></descr><parameters><param name="str" type="DOMString" attr="in"><descr><p>The name to look for.</p></descr></param></parameters><returns type="boolean"><descr><p><code>true</code>if the name has been found,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><method name="containsNS" id="NameList-containsNS"><descr><p>Test if the pair namespaceURI/name is part of this<code>NameList</code>.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The namespace URI to look for.</p></descr></param><param name="name" type="DOMString" attr="in"><descr><p>The name to look for.</p></descr></param></parameters><returns type="boolean"><descr><p><code>true</code>if the pair namespaceURI/name has been found,<code>false</code>otherwise.</p></descr></returns><raises></raises></method></interface> |
| <interface name="DOMImplementationList" id="DOMImplementationList" since="DOM Level 3"><descr><p>The<code>DOMImplementationList</code>interface provides the abstraction of an ordered collection of DOM implementations, without defining or constraining how this collection is implemented. The items in the<code>DOMImplementationList</code>are accessible via an integral index, starting from 0.</p></descr><method name="item" id="DOMImplementationList-item"><descr><p>Returns the<code>index</code>th item in the collection. If<code>index</code>is greater than or equal to the number of<code>DOMImplementation</code>s in the list, this returns<code>null</code>.</p></descr><parameters><param name="index" type="unsigned long" attr="in"><descr><p>Index into the collection.</p></descr></param></parameters><returns type="DOMImplementation"><descr><p>The<code>DOMImplementation</code>at the<code>index</code>th position in the<code>DOMImplementationList</code>, or<code>null</code>if that is not a valid index.</p></descr></returns><raises></raises></method><attribute type="unsigned long" readonly="yes" name="length" id="DOMImplementationList-length"><descr><p>The number of<code>DOMImplementation</code>s in the list. The range of valid child node indices is 0 to<code>length-1</code>inclusive.</p></descr></attribute></interface> |
| <interface name="DOMImplementationSource" id="DOMImplementationSource" since="DOM Level 3"><descr><p>This interface permits a DOM implementer to supply one or more implementations, based upon requested features and versions, as specified in<specref ref="DOMFeatures"/>. Each implemented<code>DOMImplementationSource</code>object is listed in the binding-specific list of available sources so that its<code>DOMImplementation</code>objects are made available.</p></descr><method name="getDOMImplementation" id="ID-getDOMImpl"><descr><p>A method to request the first DOM implementation that supports the specified features.</p></descr><parameters><param name="features" type="DOMString" attr="in"><descr><p>A string that specifies which features and versions are required. This is a space separated list in which each feature is specified by its name optionally followed by a space and a version number.</p><p>This method returns the first item of the list returned by<code>getDOMImplementationList</code>.</p><p>As an example, the string<code>"XML 3.0 Traversal +Events 2.0"</code>will request a DOM implementation that supports the module "XML" for its 3.0 version, a module that support of the "Traversal" module for any version, and the module "Events" for its 2.0 version. The module "Events" must be accessible using the method<code>Node.getFeature()</code>and<code>DOMImplementation.getFeature()</code>.</p></descr></param></parameters><returns type="DOMImplementation"><descr><p>The first DOM implementation that support the desired features, or<code>null</code>if this source has none.</p></descr></returns><raises></raises></method><method name="getDOMImplementationList" id="ID-getDOMImpls"><descr><p>A method to request a list of DOM implementations that support the specified features and versions, as specified in<specref ref="DOMFeatures"/>.</p></descr><parameters><param name="features" type="DOMString" attr="in"><descr><p>A string that specifies which features and versions are required. This is a space separated list in which each feature is specified by its name optionally followed by a space and a version number. This is something like: "XML 3.0 Traversal +Events 2.0"</p></descr></param></parameters><returns type="DOMImplementationList"><descr><p>A list of DOM implementations that support the desired features.</p></descr></returns><raises></raises></method></interface> |
| <interface name="DOMImplementation" id="ID-102161490"><descr><p>The<code>DOMImplementation</code>interface provides a number of methods for performing operations that are independent of any particular instance of the document object model.</p></descr><method name="hasFeature" id="ID-5CED94D7"><descr><p>Test if the DOM implementation implements a specific feature and version, as specified in<specref ref="DOMFeatures"/>.</p></descr><parameters><param name="feature" type="DOMString" attr="in"><descr><p>The name of the feature to test.</p></descr></param><param name="version" type="DOMString" attr="in"><descr><p>This is the version number of the feature to test.</p></descr></param></parameters><returns type="boolean"><descr><p><code>true</code>if the feature is implemented in the specified version,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><method name="createDocumentType" id="Level-2-Core-DOM-createDocType" since="DOM Level 2"><descr><p>Creates an empty<code>DocumentType</code>node. Entity declarations and notations are not made available. Entity reference expansions and default attribute additions do not occur..</p></descr><parameters><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The<termref def="dt-qualifiedname">qualified name</termref>of the document type to be created.</p></descr></param><param name="publicId" type="DOMString" attr="in"><descr><p>The external subset public identifier.</p></descr></param><param name="systemId" type="DOMString" attr="in"><descr><p>The external subset system identifier.</p></descr></param></parameters><returns type="DocumentType"><descr><p>A new<code>DocumentType</code>node with<code>Node.ownerDocument</code>set to<code>null</code>.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified qualified name is not an XML name according to<bibref ref="XML"/>.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is malformed.</p><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature "XML" and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><method name="createDocument" id="Level-2-Core-DOM-createDocument" since="DOM Level 2"><descr><p>Creates a DOM Document object of the specified type with its document element.</p><p>Note that based on the<code>DocumentType</code>given to create the document, the implementation may instantiate specialized<code>Document</code>objects that support additional features than the "Core", such as "HTML"<bibref role="informative" ref="DOM2HTML"/>. On the other hand, setting the<code>DocumentType</code>after the document was created makes this very unlikely to happen. Alternatively, specialized<code>Document</code>creation methods, such as<code>createHTMLDocument</code><bibref role="informative" ref="DOM2HTML"/>, can be used to obtain specific types of<code>Document</code>objects.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the document element to create or<code>null</code>.</p></descr></param><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The<termref def="dt-qualifiedname">qualified name</termref>of the document element to be created or<code>null</code>.</p></descr></param><param name="doctype" type="DocumentType" attr="in"><descr><p>The type of document to be created or<code>null</code>.</p><p>When<code>doctype</code>is not<code>null</code>, its<code>Node.ownerDocument</code>attribute is set to the document being created.</p></descr></param></parameters><returns type="Document"><descr><p>A new<code>Document</code>object with its document element. If the<code>NamespaceURI</code>,<code>qualifiedName</code>, and<code>doctype</code>are<code>null</code>, the returned<code>Document</code>is empty with no document element.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified qualified name is not an XML name according to<bibref ref="XML"/>.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is malformed, if the<code>qualifiedName</code>has a prefix and the<code>namespaceURI</code>is<code>null</code>, or if the<code>qualifiedName</code>is<code>null</code>and the<code>namespaceURI</code>is different from<code>null</code>, or if the<code>qualifiedName</code>has a prefix that is "xml" and the<code>namespaceURI</code>is different from "<loc href="http://www.w3.org/XML/1998/namespace" type="simple" show="replace" actuate="onRequest">http://www.w3.org/XML/1998/namespace</loc>"<bibref ref="Namespaces"/>, or if the DOM implementation does not support the<code>"XML"</code>feature but a non-null namespace URI was provided, since namespaces were defined by XML.</p><p>WRONG_DOCUMENT_ERR: Raised if<code>doctype</code>has already been used with a different document or was created from a different implementation.</p><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature "XML" and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><method name="getFeature" id="DOMImplementation3-getFeature" since="DOM Level 3"><descr><p>This method returns a specialized object which implements the specialized APIs of the specified feature and version, as specified in<specref ref="DOMFeatures"/>. The specialized object may also be obtained by using binding-specific casting methods but is not necessarily expected to, as discussed in<specref ref="Embedded-DOM"/>. This method also allow the implementation to provide specialized objects which do not support the<code>DOMImplementation</code>interface.</p></descr><parameters><param name="feature" type="DOMString" attr="in"><descr><p>The name of the feature requested. Note that any plus sign "+" prepended to the name of the feature will be ignored since it is not significant in the context of this method.</p></descr></param><param name="version" type="DOMString" attr="in"><descr><p>This is the version number of the feature to test.</p></descr></param></parameters><returns type="DOMObject"><descr><p>Returns an object which implements the specialized APIs of the specified feature and version, if any, or<code>null</code>if there is no object which implements interfaces associated with that feature. If the<code>DOMObject</code>returned by this method implements the<code>DOMImplementation</code>interface, it must delegate to the primary core<code>DOMImplementation</code>and not return results inconsistent with the primary core<code>DOMImplementation</code>such as<code>hasFeature</code>,<code>getFeature</code>, etc.</p></descr></returns><raises></raises></method></interface> |
| <interface name="DocumentFragment" inherits="Node" id="ID-B63ED1A3"><descr><p><code>DocumentFragment</code>is a "lightweight" or "minimal"<code>Document</code>object. It is very common to want to be able to extract a portion of a document's tree or to create a new fragment of a document. Imagine implementing a user command like cut or rearranging a document by moving fragments around. It is desirable to have an object which can hold such fragments and it is quite natural to use a Node for this purpose. While it is true that a<code>Document</code>object could fulfill this role, a<code>Document</code>object can potentially be a heavyweight object, depending on the underlying implementation. What is really needed for this is a very lightweight object.<code>DocumentFragment</code>is such an object.</p><p>Furthermore, various operations -- such as inserting nodes as children of another<code>Node</code>-- may take<code>DocumentFragment</code>objects as arguments; this results in all the child nodes of the<code>DocumentFragment</code>being moved to the child list of this node.</p><p>The children of a<code>DocumentFragment</code>node are zero or more nodes representing the tops of any sub-trees defining the structure of the document.<code>DocumentFragment</code>nodes do not need to be<termref def="dt-well-formed">well-formed XML documents</termref>(although they do need to follow the rules imposed upon well-formed XML parsed entities, which can have multiple top nodes). For example, a<code>DocumentFragment</code>might have only one child and that child node could be a<code>Text</code>node. Such a structure model represents neither an HTML document nor a well-formed XML document.</p><p>When a<code>DocumentFragment</code>is inserted into a<code>Document</code>(or indeed any other<code>Node</code>that may take children) the children of the<code>DocumentFragment</code>and not the<code>DocumentFragment</code>itself are inserted into the<code>Node</code>. This makes the<code>DocumentFragment</code>very useful when the user wishes to create nodes that are<termref def="dt-sibling">siblings</termref>; the<code>DocumentFragment</code>acts as the parent of these nodes so that the user can use the standard methods from the<code>Node</code>interface, such as<code>Node.insertBefore</code>and<code>Node.appendChild</code>.</p></descr></interface> |
| <interface name="Document" inherits="Node" id="i-Document"><descr><p>The<code>Document</code>interface represents the entire HTML or XML document. Conceptually, it is the<termref def="dt-root-node">root</termref>of the document tree, and provides the primary access to the document's data.</p><p>Since elements, text nodes, comments, processing instructions, etc. cannot exist outside the context of a<code>Document</code>, the<code>Document</code>interface also contains the factory methods needed to create these objects. The<code>Node</code>objects created have a<code>ownerDocument</code>attribute which associates them with the<code>Document</code>within whose context they were created.</p></descr><attribute id="ID-B63ED1A31" name="doctype" type="DocumentType" readonly="yes" version="DOM Level 3"><descr><p>The Document Type Declaration (see<code>DocumentType</code>) associated with this document. For XML documents without a document type declaration this returns<code>null</code>. For HTML documents, a<code>DocumentType</code>object may be returned, independently of the presence or absence of document type declaration in the HTML document.</p><p>This provides direct access to the<code>DocumentType</code>node, child node of this<code>Document</code>. This node can be set at document creation time and later changed through the use of child nodes manipulation methods, such as<code>Node.insertBefore</code>, or<code>Node.replaceChild</code>. Note, however, that while some implementations may instantiate different types of<code>Document</code>objects supporting additional features than the "Core", such as "HTML"<bibref role="informative" ref="DOM2HTML"/>, based on the<code>DocumentType</code>specified at creation time, changing it afterwards is very unlikely to result in a change of the features supported.</p></descr></attribute><attribute readonly="yes" name="implementation" type="DOMImplementation" id="ID-1B793EBA"><descr><p>The<code>DOMImplementation</code>object that handles this document. A DOM application may use objects from multiple implementations.</p></descr></attribute><attribute readonly="yes" name="documentElement" type="Element" id="ID-87CD092"><descr><p>This is a<termref def="dt-convenience">convenience</termref>attribute that allows direct access to the child node that is the<termref def="dt-document-element">document element</termref>of the document.</p></descr></attribute><method name="createElement" id="ID-2141741547"><descr><p>Creates an element of the type specified. Note that the instance returned implements the<code>Element</code>interface, so attributes can be specified directly on the returned object.</p><p>In addition, if there are known attributes with default values,<code>Attr</code>nodes representing them are automatically created and attached to the element.</p><p>To create an element with a<termref def="dt-qualifiedname">qualified name</termref>and<termref def="dt-namespaceURI">namespace URI</termref>, use the<code>createElementNS</code>method.</p></descr><parameters><param name="tagName" type="DOMString" attr="in"><descr><p>The name of the element type to instantiate. For XML, this is case-sensitive, otherwise it depends on the case-sensitivity of the markup language in use. In that case, the name is mapped to the canonical form of that markup by the DOM implementation.</p></descr></param></parameters><returns type="Element"><descr><p>A new<code>Element</code>object with the<code>nodeName</code>attribute set to<code>tagName</code>, and<code>localName</code>,<code>prefix</code>, and<code>namespaceURI</code>set to<code>null</code>.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified name is not an XML name according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute.</p></descr></exception></raises></method><method name="createDocumentFragment" id="ID-35CB04B5"><descr><p>Creates an empty<code>DocumentFragment</code>object.</p></descr><parameters></parameters><returns type="DocumentFragment"><descr><p>A new<code>DocumentFragment</code>.</p></descr></returns><raises></raises></method><method name="createTextNode" id="ID-1975348127"><descr><p>Creates a<code>Text</code>node given the specified string.</p></descr><parameters><param name="data" type="DOMString" attr="in"><descr><p>The data for the node.</p></descr></param></parameters><returns type="Text"><descr><p>The new<code>Text</code>object.</p></descr></returns><raises></raises></method><method name="createComment" id="ID-1334481328"><descr><p>Creates a<code>Comment</code>node given the specified string.</p></descr><parameters><param name="data" type="DOMString" attr="in"><descr><p>The data for the node.</p></descr></param></parameters><returns type="Comment"><descr><p>The new<code>Comment</code>object.</p></descr></returns><raises></raises></method><method name="createCDATASection" id="ID-D26C0AF8"><descr><p>Creates a<code>CDATASection</code>node whose value is the specified string.</p></descr><parameters><param name="data" type="DOMString" attr="in"><descr><p>The data for the<code>CDATASection</code>contents.</p></descr></param></parameters><returns type="CDATASection"><descr><p>The new<code>CDATASection</code>object.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.</p></descr></exception></raises></method><method name="createProcessingInstruction" id="ID-135944439"><descr><p>Creates a<code>ProcessingInstruction</code>node given the specified name and data strings.</p></descr><parameters><param name="target" type="DOMString" attr="in"><descr><p>The target part of the processing instruction.</p><p>Unlike<code>Document.createElementNS</code>or<code>Document.createAttributeNS</code>, no namespace well-formed checking is done on the target name. Applications should invoke<code>Document.normalizeDocument()</code>with the parameter "<termref def="parameter-namespaces">namespaces</termref>" set to<code>true</code>in order to ensure that the target name is namespace well-formed.</p></descr></param><param name="data" type="DOMString" attr="in"><descr><p>The data for the node.</p></descr></param></parameters><returns type="ProcessingInstruction"><descr><p>The new<code>ProcessingInstruction</code>object.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified target is not an XML name according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute.</p><p>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.</p></descr></exception></raises></method><method name="createAttribute" id="ID-1084891198"><descr><p>Creates an<code>Attr</code>of the given name. Note that the<code>Attr</code>instance can then be set on an<code>Element</code>using the<code>setAttributeNode</code>method.</p><p>To create an attribute with a<termref def="dt-qualifiedname">qualified name</termref>and<termref def="dt-namespaceURI">namespace URI</termref>, use the<code>createAttributeNS</code>method.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute.</p></descr></param></parameters><returns type="Attr"><descr><p>A new<code>Attr</code>object with the<code>nodeName</code>attribute set to<code>name</code>, and<code>localName</code>,<code>prefix</code>, and<code>namespaceURI</code>set to<code>null</code>. The value of the attribute is the empty string.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified name is not an XML name according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute.</p></descr></exception></raises></method><method name="createEntityReference" id="ID-392B75AE"><descr><p>Creates an<code>EntityReference</code>object. In addition, if the referenced entity is known, the child list of the<code>EntityReference</code>node is made the same as that of the corresponding<code>Entity</code>node.</p><note><p>If any descendant of the<code>Entity</code>node has an unbound<termref def="dt-namespaceprefix">namespace prefix</termref>, the corresponding descendant of the created<code>EntityReference</code>node is also unbound; (its<code>namespaceURI</code>is<code>null</code>). The DOM Level 2 and 3 do not support any mechanism to resolve namespace prefixes in this case.</p></note></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the entity to reference.</p><p>Unlike<code>Document.createElementNS</code>or<code>Document.createAttributeNS</code>, no namespace well-formed checking is done on the entity name. Applications should invoke<code>Document.normalizeDocument()</code>with the parameter "<termref def="parameter-namespaces">namespaces</termref>" set to<code>true</code>in order to ensure that the entity name is namespace well-formed.</p></descr></param></parameters><returns type="EntityReference"><descr><p>The new<code>EntityReference</code>object.</p></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified name is not an XML name according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute.</p><p>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.</p></descr></exception></raises></method><method name="getElementsByTagName" id="ID-A6C9094"><descr><p>Returns a<code>NodeList</code>of all the<code>Elements</code>in<termref def="dt-document-order">document order</termref>with a given tag name and are contained in the document.</p></descr><parameters><param name="tagname" type="DOMString" attr="in"><descr><p>The name of the tag to match on. The special value "*" matches all tags. For XML, the<code>tagname</code>parameter is case-sensitive, otherwise it depends on the case-sensitivity of the markup language in use.</p></descr></param></parameters><returns type="NodeList"><descr><p>A new<code>NodeList</code>object containing all the matched<code>Elements</code>.</p></descr></returns><raises></raises></method><method name="importNode" id="Core-Document-importNode" since="DOM Level 2"><descr><p>Imports a node from another document to this document, without altering or removing the source node from the original document; this method creates a new copy of the source node. The returned node has no parent; (<code>parentNode</code>is<code>null</code>).</p><p>For all nodes, importing a node creates a node object owned by the importing document, with attribute values identical to the source node's<code>nodeName</code>and<code>nodeType</code>, plus the attributes related to namespaces (<code>prefix</code>,<code>localName</code>, and<code>namespaceURI</code>). As in the<code>cloneNode</code>operation, the source node is not altered. User data associated to the imported node is not carried over. However, if any<code>UserDataHandlers</code>has been specified along with the associated data these handlers will be called with the appropriate parameters before this method returns.</p><p>Additional information is copied as appropriate to the<code>nodeType</code>, attempting to mirror the behavior expected if a fragment of XML or HTML source was copied from one document to another, recognizing that the two documents may have different DTDs in the XML case. The following list describes the specifics for each type of node.<glist><gitem><label>ATTRIBUTE_NODE</label><def><p>The<code>ownerElement</code>attribute is set to<code>null</code>and the<code>specified</code>flag is set to<code>true</code>on the generated<code>Attr</code>. The<termref def="dt-descendant">descendants</termref>of the source<code>Attr</code>are recursively imported and the resulting nodes reassembled to form the corresponding subtree.</p><p>Note that the<code>deep</code>parameter has no effect on<code>Attr</code>nodes; they always carry their children with them when imported.</p></def></gitem><gitem><label>DOCUMENT_FRAGMENT_NODE</label><def><p>If the<code>deep</code>option was set to<code>true</code>, the<termref def="dt-descendant">descendants</termref>of the source<code>DocumentFragment</code>are recursively imported and the resulting nodes reassembled under the imported<code>DocumentFragment</code>to form the corresponding subtree. Otherwise, this simply generates an empty<code>DocumentFragment</code>.</p></def></gitem><gitem><label>DOCUMENT_NODE</label><def><p><code>Document</code>nodes cannot be imported.</p></def></gitem><gitem><label>DOCUMENT_TYPE_NODE</label><def><p><code>DocumentType</code>nodes cannot be imported.</p></def></gitem><gitem><label>ELEMENT_NODE</label><def><p><emph>Specified</emph>attribute nodes of the source element are imported, and the generated<code>Attr</code>nodes are attached to the generated<code>Element</code>. Default attributes are<emph>not</emph>copied, though if the document being imported into defines default attributes for this element name, those are assigned. If the<code>importNode</code><code>deep</code>parameter was set to<code>true</code>, the<termref def="dt-descendant">descendants</termref>of the source element are recursively imported and the resulting nodes reassembled to form the corresponding subtree.</p></def></gitem><gitem><label>ENTITY_NODE</label><def><p><code>Entity</code>nodes can be imported, however in the current release of the DOM the<code>DocumentType</code>is readonly. Ability to add these imported nodes to a<code>DocumentType</code>will be considered for addition to a future release of the DOM.</p><p>On import, the<code>publicId</code>,<code>systemId</code>, and<code>notationName</code>attributes are copied. If a<code>deep</code>import is requested, the<termref def="dt-descendant">descendants</termref>of the the source<code>Entity</code>are recursively imported and the resulting nodes reassembled to form the corresponding subtree.</p></def></gitem><gitem><label>ENTITY_REFERENCE_NODE</label><def><p>Only the<code>EntityReference</code>itself is copied, even if a<code>deep</code>import is requested, since the source and destination documents might have defined the entity differently. If the document being imported into provides a definition for this entity name, its value is assigned.</p></def></gitem><gitem><label>NOTATION_NODE</label><def><p><code>Notation</code>nodes can be imported, however in the current release of the DOM the<code>DocumentType</code>is readonly. Ability to add these imported nodes to a<code>DocumentType</code>will be considered for addition to a future release of the DOM.</p><p>On import, the<code>publicId</code>and<code>systemId</code>attributes are copied.</p><p>Note that the<code>deep</code>parameter has no effect on this type of nodes since they cannot have any children.</p></def></gitem><gitem><label>PROCESSING_INSTRUCTION_NODE</label><def><p>The imported node copies its<code>target</code>and<code>data</code>values from those of the source node.</p><p>Note that the<code>deep</code>parameter has no effect on this type of nodes since they cannot have any children.</p></def></gitem><gitem><label>TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE</label><def><p>These three types of nodes inheriting from<code>CharacterData</code>copy their<code>data</code>and<code>length</code>attributes from those of the source node.</p><p>Note that the<code>deep</code>parameter has no effect on these types of nodes since they cannot have any children.</p></def></gitem></glist></p></descr><parameters><param name="importedNode" type="Node" attr="in"><descr><p>The node to import.</p></descr></param><param name="deep" type="boolean" attr="in"><descr><p>If<code>true</code>, recursively import the subtree under the specified node; if<code>false</code>, import only the node itself, as explained above. This has no effect on nodes that cannot have any children, and on<code>Attr</code>, and<code>EntityReference</code>nodes.</p></descr></param></parameters><returns type="Node"><descr><p>The imported node that belongs to this<code>Document</code>.</p></descr></returns><raises><exception name="DOMException" version="DOM Level 3"><descr><p>NOT_SUPPORTED_ERR: Raised if the type of node being imported is not supported.</p><p>INVALID_CHARACTER_ERR: Raised if one of the imported names is not an XML name according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute. This may happen when importing an XML 1.1<bibref role="informative" ref="XML11"/>element into an XML 1.0 document, for instance.</p></descr></exception></raises></method><method name="createElementNS" id="ID-DocCrElNS" since="DOM Level 2"><descr><p>Creates an element of the given<termref def="dt-qualifiedname">qualified name</termref>and<termref def="dt-namespaceURI">namespace URI</termref>.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value<code>null</code>as the namespaceURI parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the element to create.</p></descr></param><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The<termref def="dt-qualifiedname">qualified name</termref>of the element type to instantiate.</p></descr></param></parameters><returns type="Element"><descr><p>A new<code>Element</code>object with the following attributes:</p><table cellpadding="3" summary="Layout table: the first cell the name property, the second cell contains his initial value"><tbody><tr><th rowspan="1" colspan="1">Attribute</th><th rowspan="1" colspan="1">Value</th></tr><tr><td rowspan="1" colspan="1"><code>Node.nodeName</code></td><td rowspan="1" colspan="1"><code>qualifiedName</code></td></tr><tr><td rowspan="1" colspan="1"><code>Node.namespaceURI</code></td><td rowspan="1" colspan="1"><code>namespaceURI</code></td></tr><tr><td rowspan="1" colspan="1"><code>Node.prefix</code></td><td rowspan="1" colspan="1">prefix, extracted from<code>qualifiedName</code>, or<code>null</code>if there is no prefix</td></tr><tr><td rowspan="1" colspan="1"><code>Node.localName</code></td><td rowspan="1" colspan="1"><termref def="dt-localname">local name</termref>, extracted from<code>qualifiedName</code></td></tr><tr><td rowspan="1" colspan="1"><code>Element.tagName</code></td><td rowspan="1" colspan="1"><code>qualifiedName</code></td></tr></tbody></table></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified<code>qualifiedName</code>is not an XML name according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is a malformed<termref def="dt-qualifiedname">qualified name</termref>, if the<code>qualifiedName</code>has a prefix and the<code>namespaceURI</code>is<code>null</code>, or if the<code>qualifiedName</code>has a prefix that is "xml" and the<code>namespaceURI</code>is different from "<loc href="http://www.w3.org/XML/1998/namespace" type="simple" show="replace" actuate="onRequest">http://www.w3.org/XML/1998/namespace</loc>"<bibref ref="Namespaces"/>, or if the<code>qualifiedName</code>or its prefix is "xmlns" and the<code>namespaceURI</code>is different from "<loc href="http://www.w3.org/2000/xmlns/" type="simple" show="replace" actuate="onRequest">http://www.w3.org/2000/xmlns/</loc>", or if the<code>namespaceURI</code>is "<loc href="http://www.w3.org/2000/xmlns/" type="simple" show="replace" actuate="onRequest">http://www.w3.org/2000/xmlns/</loc>" and neither the<code>qualifiedName</code>nor its prefix is "xmlns".</p><p>NOT_SUPPORTED_ERR: Always thrown if the current document does not support the<code>"XML"</code>feature, since namespaces were defined by XML.</p></descr></exception></raises></method><method name="createAttributeNS" id="ID-DocCrAttrNS" since="DOM Level 2"><descr><p>Creates an attribute of the given<termref def="dt-qualifiedname">qualified name</termref>and<termref def="dt-namespaceURI">namespace URI</termref>.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value<code>null</code>as the<code>namespaceURI</code>parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to create.</p></descr></param><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The<termref def="dt-qualifiedname">qualified name</termref>of the attribute to instantiate.</p></descr></param></parameters><returns type="Attr"><descr><p>A new<code>Attr</code>object with the following attributes:</p><table cellpadding="3" summary="Layout table: the first cell the name property, the second cell contains his initial value"><tbody><tr><th rowspan="1" colspan="1">Attribute</th><th rowspan="1" colspan="1">Value</th></tr><tr><td rowspan="1" colspan="1"><code>Node.nodeName</code></td><td rowspan="1" colspan="1">qualifiedName</td></tr><tr><td rowspan="1" colspan="1"><code>Node.namespaceURI</code></td><td rowspan="1" colspan="1"><code>namespaceURI</code></td></tr><tr><td rowspan="1" colspan="1"><code>Node.prefix</code></td><td rowspan="1" colspan="1">prefix, extracted from<code>qualifiedName</code>, or<code>null</code>if there is no prefix</td></tr><tr><td rowspan="1" colspan="1"><code>Node.localName</code></td><td rowspan="1" colspan="1"><termref def="dt-localname">local name</termref>, extracted from<code>qualifiedName</code></td></tr><tr><td rowspan="1" colspan="1"><code>Attr.name</code></td><td rowspan="1" colspan="1"><code>qualifiedName</code></td></tr><tr><td rowspan="1" colspan="1"><code>Node.nodeValue</code></td><td rowspan="1" colspan="1">the empty string</td></tr></tbody></table></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified<code>qualifiedName</code>is not an XML name according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is a malformed<termref def="dt-qualifiedname">qualified name</termref>, if the<code>qualifiedName</code>has a prefix and the<code>namespaceURI</code>is<code>null</code>, if the<code>qualifiedName</code>has a prefix that is "xml" and the<code>namespaceURI</code>is different from "<loc href="http://www.w3.org/XML/1998/namespace" type="simple" show="replace" actuate="onRequest">http://www.w3.org/XML/1998/namespace</loc>", if the<code>qualifiedName</code>or its prefix is "xmlns" and the<code>namespaceURI</code>is different from "<loc href="http://www.w3.org/2000/xmlns/" type="simple" show="replace" actuate="onRequest">http://www.w3.org/2000/xmlns/</loc>", or if the<code>namespaceURI</code>is "<loc href="http://www.w3.org/2000/xmlns/" type="simple" show="replace" actuate="onRequest">http://www.w3.org/2000/xmlns/</loc>" and neither the<code>qualifiedName</code>nor its prefix is "xmlns".</p><p>NOT_SUPPORTED_ERR: Always thrown if the current document does not support the<code>"XML"</code>feature, since namespaces were defined by XML.</p></descr></exception></raises></method><method name="getElementsByTagNameNS" id="ID-getElBTNNS" since="DOM Level 2"><descr><p>Returns a<code>NodeList</code>of all the<code>Elements</code>with a given<termref def="dt-localname">local name</termref>and<termref def="dt-namespaceURI">namespace URI</termref>in<termref def="dt-document-order">document order</termref>.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the elements to match on. The special value<code>"*"</code>matches all namespaces.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the elements to match on. The special value "*" matches all local names.</p></descr></param></parameters><returns type="NodeList"><descr><p>A new<code>NodeList</code>object containing all the matched<code>Elements</code>.</p></descr></returns><raises></raises></method><method name="getElementById" id="ID-getElBId" since="DOM Level 2"><descr><p>Returns the<code>Element</code>that has an ID attribute with the given value. If no such element exists, this returns<code>null</code>. If more than one element has an ID attribute with that value, what is returned is undefined.</p><p>The DOM implementation is expected to use the attribute<code>Attr.isId</code>to determine if an attribute is of type ID.</p><note><p>Attributes with the name "ID" or "id" are not of type ID unless so defined.</p></note></descr><parameters><param name="elementId" type="DOMString" attr="in"><descr><p>The unique<code>id</code>value for an element.</p></descr></param></parameters><returns type="Element"><descr><p>The matching element or<code>null</code>if there is none.</p></descr></returns><raises></raises></method><attribute readonly="yes" type="DOMString" name="inputEncoding" id="Document3-inputEncoding" since="DOM Level 3"><descr><p>An attribute specifying the encoding used for this document at the time of the parsing. This is<code>null</code>when it is not known, such as when the<code>Document</code>was created in memory.</p></descr></attribute><attribute readonly="yes" type="DOMString" name="xmlEncoding" id="Document3-encoding" since="DOM Level 3"><descr><p>An attribute specifying, as part of the<xspecref href="http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl" type="simple" show="new" actuate="onRequest">XML declaration</xspecref>, the encoding of this document. This is<code>null</code>when unspecified or when it is not known, such as when the<code>Document</code>was created in memory.</p></descr></attribute><attribute readonly="no" type="boolean" name="xmlStandalone" id="Document3-standalone" since="DOM Level 3"><descr><p>An attribute specifying, as part of the<xspecref href="http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl" type="simple" show="new" actuate="onRequest">XML declaration</xspecref>, whether this document is standalone. This is<code>false</code>when unspecified.</p><note><p>No verification is done on the value when setting this attribute. Applications should use<code>Document.normalizeDocument()</code>with the "<termref def="parameter-validate">validate</termref>" parameter to verify if the value matches the<xspecref href="http://www.w3.org/TR/2004/REC-xml-20040204#sec-rmd" type="simple" show="new" actuate="onRequest">validity constraint for standalone document declaration</xspecref>as defined in<bibref ref="XML"/>.</p></note></descr><setraises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: Raised if this document does not support the "XML" feature.</p></descr></exception></setraises></attribute><attribute readonly="no" type="DOMString" name="xmlVersion" id="Document3-version" since="DOM Level 3"><descr><p>An attribute specifying, as part of the<xspecref href="http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl" type="simple" show="new" actuate="onRequest">XML declaration</xspecref>, the version number of this document. If there is no declaration and if this document supports the "XML" feature, the value is<code>"1.0"</code>. If this document does not support the "XML" feature, the value is always<code>null</code>. Changing this attribute will affect methods that check for invalid characters in XML names. Application should invoke<code>Document.normalizeDocument()</code>in order to check for invalid characters in the<code>Node</code>s that are already part of this<code>Document</code>.</p><p>DOM applications may use the<code>DOMImplementation.hasFeature(feature, version)</code>method with parameter values "XMLVersion" and "1.0" (respectively) to determine if an implementation supports<bibref ref="XML"/>. DOM applications may use the same method with parameter values "XMLVersion" and "1.1" (respectively) to determine if an implementation supports<bibref ref="XML11"/>. In both cases, in order to support XML, an implementation must also support the "XML" feature defined in this specification.<code>Document</code>objects supporting a version of the "XMLVersion" feature must not raise a<code>NOT_SUPPORTED_ERR</code>exception for the same version number when using<code>Document.xmlVersion</code>.</p></descr><setraises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: Raised if the version is set to a value that is not supported by this<code>Document</code>or if this document does not support the "XML" feature.</p></descr></exception></setraises></attribute><attribute readonly="no" type="boolean" name="strictErrorChecking" id="Document3-strictErrorChecking" since="DOM Level 3"><descr><p>An attribute specifying whether error checking is enforced or not. When set to<code>false</code>, the implementation is free to not test every possible error case normally defined on DOM operations, and not raise any<code>DOMException</code>on DOM operations or report errors while using<code>Document.normalizeDocument()</code>. In case of error, the behavior is undefined. This attribute is<code>true</code>by default.</p></descr></attribute><attribute name="documentURI" id="Document3-documentURI" type="DOMString" readonly="no" since="DOM Level 3"><descr><p>The location of the document or<code>null</code>if undefined or if the<code>Document</code>was created using<code>DOMImplementation.createDocument</code>. No lexical checking is performed when setting this attribute; this could result in a<code>null</code>value returned when using<code>Node.baseURI</code>.</p><p>Beware that when the<code>Document</code>supports the feature "HTML"<bibref role="informative" ref="DOM2HTML"/>, the href attribute of the HTML BASE element takes precedence over this attribute when computing<code>Node.baseURI</code>.</p></descr></attribute><method name="adoptNode" id="Document3-adoptNode" since="DOM Level 3"><descr><p>Attempts to adopt a node from another document to this document. If supported, it changes the<code>ownerDocument</code>of the source node, its children, as well as the attached attribute nodes if there are any. If the source node has a parent it is first removed from the child list of its parent. This effectively allows moving a subtree from one document to another (unlike<code>importNode()</code>which create a copy of the source node instead of moving it). When it fails, applications should use<code>Document.importNode()</code>instead. Note that if the adopted node is already part of this document (i.e. the source and target document are the same), this method still has the effect of removing the source node from the child list of its parent, if any. The following list describes the specifics for each type of node.<glist><gitem><label>ATTRIBUTE_NODE</label><def><p>The<code>ownerElement</code>attribute is set to<code>null</code>and the<code>specified</code>flag is set to<code>true</code>on the adopted<code>Attr</code>. The descendants of the source<code>Attr</code>are recursively adopted.</p></def></gitem><gitem><label>DOCUMENT_FRAGMENT_NODE</label><def><p>The descendants of the source node are recursively adopted.</p></def></gitem><gitem><label>DOCUMENT_NODE</label><def><p><code>Document</code>nodes cannot be adopted.</p></def></gitem><gitem><label>DOCUMENT_TYPE_NODE</label><def><p><code>DocumentType</code>nodes cannot be adopted.</p></def></gitem><gitem><label>ELEMENT_NODE</label><def><p><emph>Specified</emph>attribute nodes of the source element are adopted. Default attributes are discarded, though if the document being adopted into defines default attributes for this element name, those are assigned. The descendants of the source element are recursively adopted.</p></def></gitem><gitem><label>ENTITY_NODE</label><def><p><code>Entity</code>nodes cannot be adopted.</p></def></gitem><gitem><label>ENTITY_REFERENCE_NODE</label><def><p>Only the<code>EntityReference</code>node itself is adopted, the descendants are discarded, since the source and destination documents might have defined the entity differently. If the document being imported into provides a definition for this entity name, its value is assigned.</p></def></gitem><gitem><label>NOTATION_NODE</label><def><p><code>Notation</code>nodes cannot be adopted.</p></def></gitem><gitem><label>PROCESSING_INSTRUCTION_NODE, TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE</label><def><p>These nodes can all be adopted. No specifics.</p></def></gitem></glist></p><note><p>Since it does not create new nodes unlike the<code>Document.importNode()</code>method, this method does not raise an<code>INVALID_CHARACTER_ERR</code>exception, and applications should use the<code>Document.normalizeDocument()</code>method to check if an imported name is not an XML name according to the XML version in use.</p></note></descr><parameters><param attr="in" type="Node" name="source"><descr><p>The node to move into this document.</p></descr></param></parameters><returns type="Node"><descr><p>The adopted node, or<code>null</code>if this operation fails, such as when the source node comes from a different implementation.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: Raised if the source node is of type<code>DOCUMENT</code>,<code>DOCUMENT_TYPE</code>.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised when the source node is readonly.</p></descr></exception></raises></method><attribute readonly="yes" type="DOMConfiguration" name="domConfig" id="Document3-domConfig" since="DOM Level 3"><descr><p>The configuration used when<code>Document.normalizeDocument()</code>is invoked.</p></descr></attribute><method name="normalizeDocument" id="Document3-normalizeDocument" since="DOM Level 3"><descr><p>This method acts as if the document was going through a save and load cycle, putting the document in a "normal" form. As a consequence, this method updates the replacement tree of<code>EntityReference</code>nodes and normalizes<code>Text</code>nodes, as defined in the method<code>Node.normalize()</code>.</p><p>Otherwise, the actual result depends on the features being set on the<code>Document.domConfig</code>object and governing what operations actually take place. Noticeably this method could also make the document<termref def="dt-namespace-well-formed">namespace well-formed</termref>according to the algorithm described in<specref ref="normalizeDocumentAlgo"/>, check the character normalization, remove the<code>CDATASection</code>nodes, etc. See<code>DOMConfiguration</code>for details.</p><eg role="code" space="preserve">// Keep in the document the information defined // in the XML Information Set (Java example) DOMConfiguration docConfig = myDocument.getDomConfig(); docConfig.setParameter("infoset", Boolean.TRUE); myDocument.normalizeDocument();</eg><p>Mutation events, when supported, are generated to reflect the changes occurring on the document.</p><p>If errors occur during the invocation of this method, such as an attempt to update a<termref def="dt-readonly-node">read-only node</termref>or a<code>Node.nodeName</code>contains an invalid character according to the XML version in use, errors or warnings (<code>DOMError.SEVERITY_ERROR</code>or<code>DOMError.SEVERITY_WARNING</code>) will be reported using the<code>DOMErrorHandler</code>object associated with the "<termref def="parameter-error-handler">error-handler</termref>" parameter. Note this method might also report fatal errors (<code>DOMError.SEVERITY_FATAL_ERROR</code>) if an implementation cannot recover from an error.</p></descr><parameters></parameters><returns type="void"><descr><p/></descr></returns><raises></raises></method><method name="renameNode" id="Document3-renameNode" since="DOM Level 3"><descr><p>Rename an existing node of type<code>ELEMENT_NODE</code>or<code>ATTRIBUTE_NODE</code>.</p><p>When possible this simply changes the name of the given node, otherwise this creates a new node with the specified name and replaces the existing node with the new node as described below.</p><p>If simply changing the name of the given node is not possible, the following operations are performed: a new node is created, any registered event listener is registered on the new node, any user data attached to the old node is removed from that node, the old node is removed from its parent if it has one, the children are moved to the new node, if the renamed node is an<code>Element</code>its attributes are moved to the new node, the new node is inserted at the position the old node used to have in its parent's child nodes list if it has one, the user data that was attached to the old node is attached to the new node.</p><p>When the node being renamed is an<code>Element</code>only the specified attributes are moved, default attributes originated from the DTD are updated according to the new element name. In addition, the implementation may update default attributes from other schemas. Applications should use<code>Document.normalizeDocument()</code>to guarantee these attributes are up-to-date.</p><p>When the node being renamed is an<code>Attr</code>that is attached to an<code>Element</code>, the node is first removed from the<code>Element</code>attributes map. Then, once renamed, either by modifying the existing node or creating a new one as described above, it is put back.</p><p>In addition,</p><ulist><item><p>a user data event<code>NODE_RENAMED</code>is fired,</p></item><item><p>when the implementation supports the feature "MutationNameEvents", each mutation operation involved in this method fires the appropriate event, and in the end the event {<code>http://www.w3.org/2001/xml-events</code>,<code>DOMElementNameChanged</code>} or {<code>http://www.w3.org/2001/xml-events</code>,<code>DOMAttributeNameChanged</code>} is fired.</p></item></ulist></descr><parameters><param name="n" type="Node" attr="in"><descr><p>The node to rename.</p></descr></param><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The new<termref def="dt-namespaceURI">namespace URI</termref>.</p></descr></param><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The new<termref def="dt-qualifiedname">qualified name</termref>.</p></descr></param></parameters><returns type="Node"><descr><p>The renamed node. This is either the specified node or the new node that was created to replace the specified node.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: Raised when the type of the specified node is neither<code>ELEMENT_NODE</code>nor<code>ATTRIBUTE_NODE</code>, or if the implementation does not support the renaming of the<termref def="dt-document-element">document element</termref>.</p><p>INVALID_CHARACTER_ERR: Raised if the new qualified name is not an XML name according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute.</p><p>WRONG_DOCUMENT_ERR: Raised when the specified node was created from a different document than this document.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is a malformed<termref def="dt-qualifiedname">qualified name</termref>, if the<code>qualifiedName</code>has a prefix and the<code>namespaceURI</code>is<code>null</code>, or if the<code>qualifiedName</code>has a prefix that is "xml" and the<code>namespaceURI</code>is different from "<loc href="http://www.w3.org/XML/1998/namespace" type="simple" show="replace" actuate="onRequest">http://www.w3.org/XML/1998/namespace</loc>"<bibref ref="Namespaces"/>. Also raised, when the node being renamed is an attribute, if the<code>qualifiedName</code>, or its prefix, is "xmlns" and the<code>namespaceURI</code>is different from "<loc href="http://www.w3.org/2000/xmlns/" type="simple" show="replace" actuate="onRequest">http://www.w3.org/2000/xmlns/</loc>".</p></descr></exception></raises></method></interface> |
| <interface name="Node" id="ID-1950641247"><descr><p>The<code>Node</code>interface is the primary datatype for the entire Document Object Model. It represents a single node in the document tree. While all objects implementing the<code>Node</code>interface expose methods for dealing with children, not all objects implementing the<code>Node</code>interface may have children. For example,<code>Text</code>nodes may not have children, and adding children to such nodes results in a<code>DOMException</code>being raised.</p><p>The attributes<code>nodeName</code>,<code>nodeValue</code>and<code>attributes</code>are included as a mechanism to get at node information without casting down to the specific derived interface. In cases where there is no obvious mapping of these attributes for a specific<code>nodeType</code>(e.g.,<code>nodeValue</code>for an<code>Element</code>or<code>attributes</code>for a<code>Comment</code>), this returns<code>null</code>. Note that the specialized interfaces may contain additional and more convenient mechanisms to get and set the relevant information.</p></descr><group id="ID-1841493061" name="NodeType"><descr><p>An integer indicating which type of node this is.</p><note><p>Numeric codes up to 200 are reserved to W3C for possible future use.</p></note></descr><constant id="Node-ELEMENT_NODE" name="ELEMENT_NODE" type="unsigned short" value="1"><descr><p>The node is an<code>Element</code>.</p></descr></constant><constant id="Node-ATTRIBUTE_NODE" name="ATTRIBUTE_NODE" type="unsigned short" value="2"><descr><p>The node is an<code>Attr</code>.</p></descr></constant><constant id="Node-TEXT_NODE" name="TEXT_NODE" type="unsigned short" value="3"><descr><p>The node is a<code>Text</code>node.</p></descr></constant><constant id="Node-CDATA_SECTION_NODE" name="CDATA_SECTION_NODE" type="unsigned short" value="4"><descr><p>The node is a<code>CDATASection</code>.</p></descr></constant><constant id="Node-ENTITY_REFERENCE_NODE" name="ENTITY_REFERENCE_NODE" type="unsigned short" value="5"><descr><p>The node is an<code>EntityReference</code>.</p></descr></constant><constant id="Node-ENTITY_NODE" name="ENTITY_NODE" type="unsigned short" value="6"><descr><p>The node is an<code>Entity</code>.</p></descr></constant><constant id="Node-PROCESSING_INSTRUCTION_NODE" name="PROCESSING_INSTRUCTION_NODE" type="unsigned short" value="7"><descr><p>The node is a<code>ProcessingInstruction</code>.</p></descr></constant><constant id="Node-COMMENT_NODE" name="COMMENT_NODE" type="unsigned short" value="8"><descr><p>The node is a<code>Comment</code>.</p></descr></constant><constant id="Node-DOCUMENT_NODE" name="DOCUMENT_NODE" type="unsigned short" value="9"><descr><p>The node is a<code>Document</code>.</p></descr></constant><constant id="Node-DOCUMENT_TYPE_NODE" name="DOCUMENT_TYPE_NODE" type="unsigned short" value="10"><descr><p>The node is a<code>DocumentType</code>.</p></descr></constant><constant id="Node-DOCUMENT_FRAGMENT_NODE" name="DOCUMENT_FRAGMENT_NODE" type="unsigned short" value="11"><descr><p>The node is a<code>DocumentFragment</code>.</p></descr></constant><constant id="Node-NOTATION_NODE" name="NOTATION_NODE" type="unsigned short" value="12"><descr><p>The node is a<code>Notation</code>.</p></descr></constant></group><p>The values of<code>nodeName</code>,<code>nodeValue</code>, and<code>attributes</code>vary according to the node type as follows:<table cellpadding="3" summary="Layout table: the first cell contains the name of the interface, the second contains the value of the nodeName attribute for this interface, the third contains the value of the nodeValue attribute for this interface and the fourth contains the value of the attributes attribute for this interface" border="1"><tbody><tr><th rowspan="1" colspan="1">Interface</th><th rowspan="1" colspan="1">nodeName</th><th rowspan="1" colspan="1">nodeValue</th><th rowspan="1" colspan="1">attributes</th></tr><tr><td rowspan="1" colspan="1"><code>Attr</code></td><td rowspan="1" colspan="1">same as<code>Attr.name</code></td><td rowspan="1" colspan="1">same as<code>Attr.value</code></td><td rowspan="1" colspan="1"><code>null</code></td></tr><tr><td rowspan="1" colspan="1"><code>CDATASection</code></td><td rowspan="1" colspan="1"><code>"#cdata-section"</code></td><td rowspan="1" colspan="1">same as<code>CharacterData.data</code>, the content of the CDATA Section</td><td rowspan="1" colspan="1"><code>null</code></td></tr><tr><td rowspan="1" colspan="1"><code>Comment</code></td><td rowspan="1" colspan="1"><code>"#comment"</code></td><td rowspan="1" colspan="1">same as<code>CharacterData.data</code>, the content of the comment</td><td rowspan="1" colspan="1"><code>null</code></td></tr><tr><td rowspan="1" colspan="1"><code>Document</code></td><td rowspan="1" colspan="1"><code>"#document"</code></td><td rowspan="1" colspan="1"><code>null</code></td><td rowspan="1" colspan="1"><code>null</code></td></tr><tr><td rowspan="1" colspan="1"><code>DocumentFragment</code></td><td rowspan="1" colspan="1"><code>"#document-fragment"</code></td><td rowspan="1" colspan="1"><code>null</code></td><td rowspan="1" colspan="1"><code>null</code></td></tr><tr><td rowspan="1" colspan="1"><code>DocumentType</code></td><td rowspan="1" colspan="1">same as<code>DocumentType.name</code></td><td rowspan="1" colspan="1"><code>null</code></td><td rowspan="1" colspan="1"><code>null</code></td></tr><tr><td rowspan="1" colspan="1"><code>Element</code></td><td rowspan="1" colspan="1">same as<code>Element.tagName</code></td><td rowspan="1" colspan="1"><code>null</code></td><td rowspan="1" colspan="1"><code>NamedNodeMap</code></td></tr><tr><td rowspan="1" colspan="1"><code>Entity</code></td><td rowspan="1" colspan="1">entity name</td><td rowspan="1" colspan="1"><code>null</code></td><td rowspan="1" colspan="1"><code>null</code></td></tr><tr><td rowspan="1" colspan="1"><code>EntityReference</code></td><td rowspan="1" colspan="1">name of entity referenced</td><td rowspan="1" colspan="1"><code>null</code></td><td rowspan="1" colspan="1"><code>null</code></td></tr><tr><td rowspan="1" colspan="1"><code>Notation</code></td><td rowspan="1" colspan="1">notation name</td><td rowspan="1" colspan="1"><code>null</code></td><td rowspan="1" colspan="1"><code>null</code></td></tr><tr><td rowspan="1" colspan="1"><code>ProcessingInstruction</code></td><td rowspan="1" colspan="1">same as<code>ProcessingInstruction.target</code></td><td rowspan="1" colspan="1">same as<code>ProcessingInstruction.data</code></td><td rowspan="1" colspan="1"><code>null</code></td></tr><tr><td rowspan="1" colspan="1"><code>Text</code></td><td rowspan="1" colspan="1"><code>"#text"</code></td><td rowspan="1" colspan="1">same as<code>CharacterData.data</code>, the content of the text node</td><td rowspan="1" colspan="1"><code>null</code></td></tr></tbody></table></p><attribute type="DOMString" readonly="yes" name="nodeName" id="ID-F68D095"><descr><p>The name of this node, depending on its type; see the table above.</p></descr></attribute><attribute type="DOMString" name="nodeValue" id="ID-F68D080" readonly="no"><descr><p>The value of this node, depending on its type; see the table above. When it is defined to be<code>null</code>, setting it has no effect, including if the node is<termref def="dt-readonly-node">read-only</termref>.</p></descr><setraises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly and if it is not defined to be<code>null</code>.</p></descr></exception></setraises><getraises><exception name="DOMException"><descr><p>DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a<code>DOMString</code>variable on the implementation platform.</p></descr></exception></getraises></attribute><attribute type="unsigned short" name="nodeType" readonly="yes" id="ID-111237558"><descr><p>A code representing the type of the underlying object, as defined above.</p></descr></attribute><attribute type="Node" readonly="yes" name="parentNode" id="ID-1060184317"><descr><p>The<termref def="dt-parent">parent</termref>of this node. All nodes, except<code>Attr</code>,<code>Document</code>,<code>DocumentFragment</code>,<code>Entity</code>, and<code>Notation</code>may have a parent. However, if a node has just been created and not yet added to the tree, or if it has been removed from the tree, this is<code>null</code>.</p></descr></attribute><attribute type="NodeList" readonly="yes" name="childNodes" id="ID-1451460987"><descr><p>A<code>NodeList</code>that contains all children of this node. If there are no children, this is a<code>NodeList</code>containing no nodes.</p></descr></attribute><attribute readonly="yes" type="Node" name="firstChild" id="ID-169727388"><descr><p>The first child of this node. If there is no such node, this returns<code>null</code>.</p></descr></attribute><attribute readonly="yes" type="Node" name="lastChild" id="ID-61AD09FB"><descr><p>The last child of this node. If there is no such node, this returns<code>null</code>.</p></descr></attribute><attribute readonly="yes" type="Node" name="previousSibling" id="ID-640FB3C8"><descr><p>The node immediately preceding this node. If there is no such node, this returns<code>null</code>.</p></descr></attribute><attribute readonly="yes" type="Node" name="nextSibling" id="ID-6AC54C2F"><descr><p>The node immediately following this node. If there is no such node, this returns<code>null</code>.</p></descr></attribute><attribute readonly="yes" type="NamedNodeMap" name="attributes" id="ID-84CF096"><descr><p>A<code>NamedNodeMap</code>containing the attributes of this node (if it is an<code>Element</code>) or<code>null</code>otherwise.</p></descr></attribute><attribute readonly="yes" type="Document" name="ownerDocument" id="node-ownerDoc" version="DOM Level 2"><descr><p>The<code>Document</code>object associated with this node. This is also the<code>Document</code>object used to create new nodes. When this node is a<code>Document</code>or a<code>DocumentType</code>which is not used with any<code>Document</code>yet, this is<code>null</code>.</p></descr></attribute><method name="insertBefore" id="ID-952280727" version="DOM Level 3"><descr><p>Inserts the node<code>newChild</code>before the existing child node<code>refChild</code>. If<code>refChild</code>is<code>null</code>, insert<code>newChild</code>at the end of the list of children.</p><p>If<code>newChild</code>is a<code>DocumentFragment</code>object, all of its children are inserted, in the same order, before<code>refChild</code>. If the<code>newChild</code>is already in the tree, it is first removed.</p><note><p>Inserting a node before itself is implementation dependent.</p></note></descr><parameters><param name="newChild" type="Node" attr="in"><descr><p>The node to insert.</p></descr></param><param name="refChild" type="Node" attr="in"><descr><p>The reference node, i.e., the node before which the new node must be inserted.</p></descr></param></parameters><returns type="Node"><descr><p>The node being inserted.</p></descr></returns><raises><exception name="DOMException"><descr><p>HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the<code>newChild</code>node, or if the node to insert is one of this node's<termref def="dt-ancestor">ancestors</termref>or this node itself, or if this node is of type<code>Document</code>and the DOM application attempts to insert a second<code>DocumentType</code>or<code>Element</code>node.</p><p>WRONG_DOCUMENT_ERR: Raised if<code>newChild</code>was created from a different document than the one that created this node.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or if the parent of the node being inserted is readonly.</p><p>NOT_FOUND_ERR: Raised if<code>refChild</code>is not a child of this node.</p><p>NOT_SUPPORTED_ERR: if this node is of type<code>Document</code>, this exception might be raised if the DOM implementation doesn't support the insertion of a<code>DocumentType</code>or<code>Element</code>node.</p></descr></exception></raises></method><method name="replaceChild" id="ID-785887307" version="DOM Level 3"><descr><p>Replaces the child node<code>oldChild</code>with<code>newChild</code>in the list of children, and returns the<code>oldChild</code>node.</p><p>If<code>newChild</code>is a<code>DocumentFragment</code>object,<code>oldChild</code>is replaced by all of the<code>DocumentFragment</code>children, which are inserted in the same order. If the<code>newChild</code>is already in the tree, it is first removed.</p><note><p>Replacing a node with itself is implementation dependent.</p></note></descr><parameters><param name="newChild" type="Node" attr="in"><descr><p>The new node to put in the child list.</p></descr></param><param name="oldChild" type="Node" attr="in"><descr><p>The node being replaced in the list.</p></descr></param></parameters><returns type="Node"><descr><p>The node replaced.</p></descr></returns><raises><exception name="DOMException"><descr><p>HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the<code>newChild</code>node, or if the node to put in is one of this node's<termref def="dt-ancestor">ancestors</termref>or this node itself, or if this node is of type<code>Document</code>and the result of the replacement operation would add a second<code>DocumentType</code>or<code>Element</code>on the<code>Document</code>node.</p><p>WRONG_DOCUMENT_ERR: Raised if<code>newChild</code>was created from a different document than the one that created this node.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the parent of the new node is readonly.</p><p>NOT_FOUND_ERR: Raised if<code>oldChild</code>is not a child of this node.</p><p>NOT_SUPPORTED_ERR: if this node is of type<code>Document</code>, this exception might be raised if the DOM implementation doesn't support the replacement of the<code>DocumentType</code>child or<code>Element</code>child.</p></descr></exception></raises></method><method name="removeChild" id="ID-1734834066" version="DOM Level 3"><descr><p>Removes the child node indicated by<code>oldChild</code>from the list of children, and returns it.</p></descr><parameters><param name="oldChild" type="Node" attr="in"><descr><p>The node being removed.</p></descr></param></parameters><returns type="Node"><descr><p>The node removed.</p></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NOT_FOUND_ERR: Raised if<code>oldChild</code>is not a child of this node.</p><p>NOT_SUPPORTED_ERR: if this node is of type<code>Document</code>, this exception might be raised if the DOM implementation doesn't support the removal of the<code>DocumentType</code>child or the<code>Element</code>child.</p></descr></exception></raises></method><method name="appendChild" id="ID-184E7107" version="DOM Level 3"><descr><p>Adds the node<code>newChild</code>to the end of the list of children of this node. If the<code>newChild</code>is already in the tree, it is first removed.</p></descr><parameters><param name="newChild" type="Node" attr="in"><descr><p>The node to add.</p><p>If it is a<code>DocumentFragment</code>object, the entire contents of the document fragment are moved into the child list of this node</p></descr></param></parameters><returns type="Node"><descr><p>The node added.</p></descr></returns><raises><exception name="DOMException"><descr><p>HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the<code>newChild</code>node, or if the node to append is one of this node's<termref def="dt-ancestor">ancestors</termref>or this node itself, or if this node is of type<code>Document</code>and the DOM application attempts to append a second<code>DocumentType</code>or<code>Element</code>node.</p><p>WRONG_DOCUMENT_ERR: Raised if<code>newChild</code>was created from a different document than the one that created this node.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or if the previous parent of the node being inserted is readonly.</p><p>NOT_SUPPORTED_ERR: if the<code>newChild</code>node is a child of the<code>Document</code>node, this exception might be raised if the DOM implementation doesn't support the removal of the<code>DocumentType</code>child or<code>Element</code>child.</p></descr></exception></raises></method><method name="hasChildNodes" id="ID-810594187"><descr><p>Returns whether this node has any children.</p></descr><parameters></parameters><returns type="boolean"><descr><p>Returns<code>true</code>if this node has any children,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><method name="cloneNode" id="ID-3A0ED0A4"><descr><p>Returns a duplicate of this node, i.e., serves as a generic copy constructor for nodes. The duplicate node has no parent (<code>parentNode</code>is<code>null</code>) and no user data. User data associated to the imported node is not carried over. However, if any<code>UserDataHandlers</code>has been specified along with the associated data these handlers will be called with the appropriate parameters before this method returns.</p><p>Cloning an<code>Element</code>copies all attributes and their values, including those generated by the XML processor to represent defaulted attributes, but this method does not copy any children it contains unless it is a deep clone. This includes text contained in an the<code>Element</code>since the text is contained in a child<code>Text</code>node. Cloning an<code>Attr</code>directly, as opposed to be cloned as part of an<code>Element</code>cloning operation, returns a specified attribute (<code>specified</code>is<code>true</code>). Cloning an<code>Attr</code>always clones its children, since they represent its value, no matter whether this is a deep clone or not. Cloning an<code>EntityReference</code>automatically constructs its subtree if a corresponding<code>Entity</code>is available, no matter whether this is a deep clone or not. Cloning any other type of node simply returns a copy of this node.</p><p>Note that cloning an immutable subtree results in a mutable copy, but the children of an<code>EntityReference</code>clone are<termref def="dt-readonly-node">readonly</termref>. In addition, clones of unspecified<code>Attr</code>nodes are specified. And, cloning<code>Document</code>,<code>DocumentType</code>,<code>Entity</code>, and<code>Notation</code>nodes is implementation dependent.</p></descr><parameters><param name="deep" type="boolean" attr="in"><descr><p>If<code>true</code>, recursively clone the subtree under the specified node; if<code>false</code>, clone only the node itself (and its attributes, if it is an<code>Element</code>).</p></descr></param></parameters><returns type="Node"><descr><p>The duplicate node.</p></descr></returns><raises></raises></method><method id="ID-normalize" name="normalize" version="DOM Level 3"><descr><p>Puts all<code>Text</code>nodes in the full depth of the sub-tree underneath this<code>Node</code>, including attribute nodes, into a "normal" form where only structure (e.g., elements, comments, processing instructions, CDATA sections, and entity references) separates<code>Text</code>nodes, i.e., there are neither adjacent<code>Text</code>nodes nor empty<code>Text</code>nodes. This can be used to ensure that the DOM view of a document is the same as if it were saved and re-loaded, and is useful when operations (such as XPointer<bibref role="informative" ref="XPointer"/>lookups) that depend on a particular document tree structure are to be used. If the parameter "<termref def="parameter-normalize-characters">normalize-characters</termref>" of the<code>DOMConfiguration</code>object attached to the<code>Node.ownerDocument</code>is<code>true</code>, this method will also fully normalize the characters of the<code>Text</code>nodes.</p><note><p>In cases where the document contains<code>CDATASections</code>, the normalize operation alone may not be sufficient, since XPointers do not differentiate between<code>Text</code>nodes and<code>CDATASection</code>nodes.</p></note></descr><parameters></parameters><returns type="void"><descr><p/></descr></returns><raises></raises></method><method name="isSupported" id="Level-2-Core-Node-supports" since="DOM Level 2"><descr><p>Tests whether the DOM implementation implements a specific feature and that feature is supported by this node, as specified in<specref ref="DOMFeatures"/>.</p></descr><parameters><param name="feature" type="DOMString" attr="in"><descr><p>The name of the feature to test.</p></descr></param><param name="version" type="DOMString" attr="in"><descr><p>This is the version number of the feature to test.</p></descr></param></parameters><returns type="boolean"><descr><p>Returns<code>true</code>if the specified feature is supported on this node,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><attribute readonly="yes" type="DOMString" name="namespaceURI" id="ID-NodeNSname" since="DOM Level 2"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of this node, or<code>null</code>if it is unspecified (see<specref ref="Namespaces-Considerations"/>).</p><p>This is not a computed value that is the result of a namespace lookup based on an examination of the namespace declarations in scope. It is merely the namespace URI given at creation time.</p><p>For nodes of any type other than<code>ELEMENT_NODE</code>and<code>ATTRIBUTE_NODE</code>and nodes created with a DOM Level 1 method, such as<code>Document.createElement()</code>, this is always<code>null</code>.</p><note><p>Per the<emph>Namespaces in XML</emph>Specification<bibref ref="Namespaces"/>an attribute does not inherit its namespace from the element it is attached to. If an attribute is not explicitly given a namespace, it simply has no namespace.</p></note></descr></attribute><attribute type="DOMString" name="prefix" id="ID-NodeNSPrefix" since="DOM Level 2" readonly="no"><descr><p>The<termref def="dt-namespaceprefix">namespace prefix</termref>of this node, or<code>null</code>if it is unspecified. When it is defined to be<code>null</code>, setting it has no effect, including if the node is<termref def="dt-readonly-node">read-only</termref>.</p><p>Note that setting this attribute, when permitted, changes the<code>nodeName</code>attribute, which holds the<termref def="dt-qualifiedname">qualified name</termref>, as well as the<code>tagName</code>and<code>name</code>attributes of the<code>Element</code>and<code>Attr</code>interfaces, when applicable.</p><p>Setting the prefix to<code>null</code>makes it unspecified, setting it to an empty string is implementation dependent.</p><p>Note also that changing the prefix of an attribute that is known to have a default value, does not make a new attribute with the default value and the original prefix appear, since the<code>namespaceURI</code>and<code>localName</code>do not change.</p><p>For nodes of any type other than<code>ELEMENT_NODE</code>and<code>ATTRIBUTE_NODE</code>and nodes created with a DOM Level 1 method, such as<code>createElement</code>from the<code>Document</code>interface, this is always<code>null</code>.</p></descr><setraises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NAMESPACE_ERR: Raised if the specified<code>prefix</code>is malformed per the Namespaces in XML specification, if the<code>namespaceURI</code>of this node is<code>null</code>, if the specified prefix is "xml" and the<code>namespaceURI</code>of this node is different from "<loc href="http://www.w3.org/XML/1998/namespace" type="simple" show="replace" actuate="onRequest">http://www.w3.org/XML/1998/namespace</loc>", if this node is an attribute and the specified prefix is "xmlns" and the<code>namespaceURI</code>of this node is different from "<loc href="http://www.w3.org/2000/xmlns/" type="simple" show="replace" actuate="onRequest">http://www.w3.org/2000/xmlns/</loc>", or if this node is an attribute and the<code>qualifiedName</code>of this node is "xmlns"<bibref ref="Namespaces"/>.</p></descr></exception></setraises></attribute><attribute readonly="yes" type="DOMString" name="localName" id="ID-NodeNSLocalN" since="DOM Level 2"><descr><p>Returns the local part of the<termref def="dt-qualifiedname">qualified name</termref>of this node.</p><p>For nodes of any type other than<code>ELEMENT_NODE</code>and<code>ATTRIBUTE_NODE</code>and nodes created with a DOM Level 1 method, such as<code>Document.createElement()</code>, this is always<code>null</code>.</p></descr></attribute><method name="hasAttributes" id="ID-NodeHasAttrs" since="DOM Level 2"><descr><p>Returns whether this node (if it is an element) has any attributes.</p></descr><parameters></parameters><returns type="boolean"><descr><p>Returns<code>true</code>if this node has any attributes,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><attribute readonly="yes" type="DOMString" name="baseURI" id="Node3-baseURI" since="DOM Level 3"><descr><p>The absolute base URI of this node or<code>null</code>if the implementation wasn't able to obtain an absolute URI. This value is computed as described in<specref ref="baseURIs-Considerations"/>. However, when the<code>Document</code>supports the feature "HTML"<bibref role="informative" ref="DOM2HTML"/>, the base URI is computed using first the value of the href attribute of the HTML BASE element if any, and the value of the<code>documentURI</code>attribute from the<code>Document</code>interface otherwise.</p></descr></attribute><group id="DocumentPosition" name="DocumentPosition" since="DOM Level 3"><descr><p>A bitmask indicating the relative document position of a node with respect to another node.</p><p>If the two nodes being compared are the same node, then no flags are set on the return.</p><p>Otherwise, the order of two nodes is determined by looking for common containers -- containers which contain both. A node directly contains any child nodes. A node also directly contains any other nodes attached to it such as attributes contained in an element or entities and notations contained in a document type. Nodes contained in contained nodes are also contained, but less-directly as the number of intervening containers increases.</p><p>If there is no common container node, then the order is based upon order between the root container of each node that is in no container. In this case, the result is disconnected and implementation-specific. This result is stable as long as these outer-most containing nodes remain in memory and are not inserted into some other containing node. This would be the case when the nodes belong to different documents or fragments, and cloning the document or inserting a fragment might change the order.</p><p>If one of the nodes being compared contains the other node, then the container precedes the contained node, and reversely the contained node follows the container. For example, when comparing an element against its own attribute or child, the element node precedes its attribute node and its child node, which both follow it.</p><p>If neither of the previous cases apply, then there exists a most-direct container common to both nodes being compared. In this case, the order is determined based upon the two determining nodes directly contained in this most-direct common container that either are or contain the corresponding nodes being compared.</p><p>If these two determining nodes are both child nodes, then the natural DOM order of these determining nodes within the containing node is returned as the order of the corresponding nodes. This would be the case, for example, when comparing two child elements of the same element.</p><p>If one of the two determining nodes is a child node and the other is not, then the corresponding node of the child node follows the corresponding node of the non-child node. This would be the case, for example, when comparing an attribute of an element with a child element of the same element.</p><p>If neither of the two determining node is a child node and one determining node has a greater value of<code>nodeType</code>than the other, then the corresponding node precedes the other. This would be the case, for example, when comparing an entity of a document type against a notation of the same document type.</p><p>If neither of the two determining node is a child node and<code>nodeType</code>is the same for both determining nodes, then an implementation-dependent order between the determining nodes is returned. This order is stable as long as no nodes of the same nodeType are inserted into or removed from the direct container. This would be the case, for example, when comparing two attributes of the same element, and inserting or removing additional attributes might change the order between existing attributes.</p></descr><constant id="Node-DOCUMENT_POSITION_DISCONNECTED" name="DOCUMENT_POSITION_DISCONNECTED" type="unsigned short" value="0x01"><descr><p>The two nodes are disconnected. Order between disconnected nodes is always implementation-specific.</p></descr></constant><constant id="Node-DOCUMENT_POSITION_PRECEDING" name="DOCUMENT_POSITION_PRECEDING" type="unsigned short" value="0x02"><descr><p>The second node precedes the reference node.</p></descr></constant><constant id="Node-DOCUMENT_POSITION_FOLLOWING" name="DOCUMENT_POSITION_FOLLOWING" type="unsigned short" value="0x04"><descr><p>The node follows the reference node.</p></descr></constant><constant id="Node-DOCUMENT_POSITION_CONTAINS" name="DOCUMENT_POSITION_CONTAINS" type="unsigned short" value="0x08"><descr><p>The node contains the reference node. A node which contains is always preceding, too.</p></descr></constant><constant id="Node-DOCUMENT_POSITION_CONTAINED_BY" name="DOCUMENT_POSITION_CONTAINED_BY" type="unsigned short" value="0x10"><descr><p>The node is contained by the reference node. A node which is contained is always following, too.</p></descr></constant><constant id="Node-DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC" name="DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC" type="unsigned short" value="0x20"><descr><p>The determination of preceding versus following is implementation-specific.</p></descr></constant></group><method name="compareDocumentPosition" id="Node3-compareDocumentPosition" since="DOM Level 3"><descr><p>Compares the reference node, i.e. the node on which this method is being called, with a node, i.e. the one passed as a parameter, with regard to their position in the document and according to the<termref def="dt-document-order">document order</termref>.</p></descr><parameters><param attr="in" type="Node" name="other"><descr><p>The node to compare against the reference node.</p></descr></param></parameters><returns type="unsigned short"><descr><p>Returns how the node is positioned relatively to the reference node.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: when the compared nodes are from different DOM implementations that do not coordinate to return consistent implementation-specific results.</p></descr></exception></raises></method><attribute name="textContent" id="Node3-textContent" type="DOMString" readonly="no" since="DOM Level 3"><descr><p>This attribute returns the text content of this node and its descendants. When it is defined to be<code>null</code>, setting it has no effect. On setting, any possible children this node may have are removed and, if it the new string is not empty or<code>null</code>, replaced by a single<code>Text</code>node containing the string this attribute is set to.</p><p>On getting, no serialization is performed, the returned string does not contain any markup. No whitespace normalization is performed and the returned string does not contain the white spaces in element content (see the attribute<code>Text.isElementContentWhitespace</code>). Similarly, on setting, no parsing is performed either, the input string is taken as pure textual content.</p><p>The string returned is made of the text content of this node depending on its type, as defined below:</p><table cellpadding="3" summary="The string returned is made of the text content of the node. The first cell of this table contains the type of the Node, the second cell indicates the string returned by textContent." border="1"><tbody><tr><th rowspan="1" colspan="1">Node type</th><th rowspan="1" colspan="1">Content</th></tr><tr><td rowspan="1" colspan="1">ELEMENT_NODE, ATTRIBUTE_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, DOCUMENT_FRAGMENT_NODE</td><td rowspan="1" colspan="1">concatenation of the<code>textContent</code>attribute value of every child node, excluding COMMENT_NODE and PROCESSING_INSTRUCTION_NODE nodes. This is the empty string if the node has no children.</td></tr><tr><td rowspan="1" colspan="1">TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE</td><td rowspan="1" colspan="1"><code>nodeValue</code></td></tr><tr><td rowspan="1" colspan="1">DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE</td><td rowspan="1" colspan="1"><emph>null</emph></td></tr></tbody></table></descr><setraises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p></descr></exception></setraises><getraises><exception name="DOMException"><descr><p>DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a<code>DOMString</code>variable on the implementation platform.</p></descr></exception></getraises></attribute><method name="isSameNode" id="Node3-isSameNode" since="DOM Level 3"><descr><p>Returns whether this node is the same node as the given one.</p><p>This method provides a way to determine whether two<code>Node</code>references returned by the implementation reference the same object. When two<code>Node</code>references are references to the same object, even if through a proxy, the references may be used completely interchangeably, such that all attributes have the same values and calling the same DOM method on either reference always has exactly the same effect.</p></descr><parameters><param attr="in" type="Node" name="other"><descr><p>The node to test against.</p></descr></param></parameters><returns type="boolean"><descr><p>Returns<code>true</code>if the nodes are the same,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><method name="lookupPrefix" id="Node3-lookupNamespacePrefix" since="DOM Level 3"><descr><p>Look up the prefix associated to the given namespace URI, starting from this node. The default namespace declarations are ignored by this method.</p><p>See<specref ref="lookupNamespacePrefixAlgo"/>for details on the algorithm used by this method.</p></descr><parameters><param attr="in" type="DOMString" name="namespaceURI"><descr><p>The namespace URI to look for.</p></descr></param></parameters><returns type="DOMString"><descr><p>Returns an associated namespace prefix if found or<code>null</code>if none is found. If more than one prefix are associated to the namespace prefix, the returned namespace prefix is implementation dependent.</p></descr></returns><raises></raises></method><method name="isDefaultNamespace" id="Node3-isDefaultNamespace" since="DOM Level 3"><descr><p>This method checks if the specified<code>namespaceURI</code>is the default namespace or not.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The namespace URI to look for.</p></descr></param></parameters><returns type="boolean"><descr><p>Returns<code>true</code>if the specified<code>namespaceURI</code>is the default namespace,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><method name="lookupNamespaceURI" id="Node3-lookupNamespaceURI" since="DOM Level 3"><descr><p>Look up the namespace URI associated to the given prefix, starting from this node.</p><p>See<specref ref="lookupNamespaceURIAlgo"/>for details on the algorithm used by this method.</p></descr><parameters><param attr="in" type="DOMString" name="prefix"><descr><p>The prefix to look for. If this parameter is<code>null</code>, the method will return the default namespace URI if any.</p></descr></param></parameters><returns type="DOMString"><descr><p>Returns the associated namespace URI or<code>null</code>if none is found.</p></descr></returns><raises></raises></method><method name="isEqualNode" id="Node3-isEqualNode" since="DOM Level 3"><descr><p>Tests whether two nodes are equal.</p><p>This method tests for equality of nodes, not sameness (i.e., whether the two nodes are references to the same object) which can be tested with<code>Node.isSameNode()</code>. All nodes that are the same will also be equal, though the reverse may not be true.</p><p>Two nodes are equal if and only if the following conditions are satisfied:<ulist><item><p>The two nodes are of the same type.</p></item><item><p>The following string attributes are equal:<code>nodeName</code>,<code>localName</code>,<code>namespaceURI</code>,<code>prefix</code>,<code>nodeValue</code>. This is: they are both<code>null</code>, or they have the same length and are character for character identical.</p></item><item><p>The<code>attributes</code><code>NamedNodeMaps</code>are equal. This is: they are both<code>null</code>, or they have the same length and for each node that exists in one map there is a node that exists in the other map and is equal, although not necessarily at the same index.</p></item><item><p>The<code>childNodes</code><code>NodeLists</code>are equal. This is: they are both<code>null</code>, or they have the same length and contain equal nodes at the same index. Note that normalization can affect equality; to avoid this, nodes should be normalized before being compared.</p></item></ulist></p><p>For two<code>DocumentType</code>nodes to be equal, the following conditions must also be satisfied:<ulist><item><p>The following string attributes are equal:<code>publicId</code>,<code>systemId</code>,<code>internalSubset</code>.</p></item><item><p>The<code>entities</code><code>NamedNodeMaps</code>are equal.</p></item><item><p>The<code>notations</code><code>NamedNodeMaps</code>are equal.</p></item></ulist></p><p>On the other hand, the following do not affect equality: the<code>ownerDocument</code>,<code>baseURI</code>, and<code>parentNode</code>attributes, the<code>specified</code>attribute for<code>Attr</code>nodes, the<code>schemaTypeInfo</code>attribute for<code>Attr</code>and<code>Element</code>nodes, the<code>Text.isElementContentWhitespace</code>attribute for<code>Text</code>nodes, as well as any user data or event listeners registered on the nodes.</p><note><p>As a general rule, anything not mentioned in the description above is not significant in consideration of equality checking. Note that future versions of this specification may take into account more attributes and implementations conform to this specification are expected to be updated accordingly.</p></note></descr><parameters><param name="arg" type="Node" attr="in"><descr><p>The node to compare equality with.</p></descr></param></parameters><returns type="boolean"><descr><p>Returns<code>true</code>if the nodes are equal,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><method name="getFeature" id="Node3-getFeature" since="DOM Level 3"><descr><p>This method returns a specialized object which implements the specialized APIs of the specified feature and version, as specified in<specref ref="DOMFeatures"/>. The specialized object may also be obtained by using binding-specific casting methods but is not necessarily expected to, as discussed in<specref ref="Embedded-DOM"/>. This method also allow the implementation to provide specialized objects which do not support the<code>Node</code>interface.</p></descr><parameters><param name="feature" type="DOMString" attr="in"><descr><p>The name of the feature requested. Note that any plus sign "+" prepended to the name of the feature will be ignored since it is not significant in the context of this method.</p></descr></param><param name="version" type="DOMString" attr="in"><descr><p>This is the version number of the feature to test.</p></descr></param></parameters><returns type="DOMObject"><descr><p>Returns an object which implements the specialized APIs of the specified feature and version, if any, or<code>null</code>if there is no object which implements interfaces associated with that feature. If the<code>DOMObject</code>returned by this method implements the<code>Node</code>interface, it must delegate to the primary core<code>Node</code>and not return results inconsistent with the primary core<code>Node</code>such as attributes, childNodes, etc.</p></descr></returns><raises></raises></method><method name="setUserData" id="Node3-setUserData" since="DOM Level 3"><descr><p>Associate an object to a key on this node. The object can later be retrieved from this node by calling<code>getUserData</code>with the same key.</p></descr><parameters><param name="key" type="DOMString" attr="in"><descr><p>The key to associate the object to.</p></descr></param><param name="data" type="DOMUserData" attr="in"><descr><p>The object to associate to the given key, or<code>null</code>to remove any existing association to that key.</p></descr></param><param name="handler" type="UserDataHandler" attr="in"><descr><p>The handler to associate to that key, or<code>null</code>.</p></descr></param></parameters><returns type="DOMUserData"><descr><p>Returns the<code>DOMUserData</code>previously associated to the given key on this node, or<code>null</code>if there was none.</p></descr></returns><raises></raises></method><method name="getUserData" id="Node3-getUserData" since="DOM Level 3"><descr><p>Retrieves the object associated to a key on a this node. The object must first have been set to this node by calling<code>setUserData</code>with the same key.</p></descr><parameters><param name="key" type="DOMString" attr="in"><descr><p>The key the object is associated to.</p></descr></param></parameters><returns type="DOMUserData"><descr><p>Returns the<code>DOMUserData</code>associated to the given key on this node, or<code>null</code>if there was none.</p></descr></returns><raises></raises></method></interface> |
| <interface name="NodeList" id="ID-536297177"><descr><p>The<code>NodeList</code>interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented.<code>NodeList</code>objects in the DOM are<termref def="td-live">live</termref>.</p><p>The items in the<code>NodeList</code>are accessible via an integral index, starting from 0.</p></descr><method name="item" id="ID-844377136"><descr><p>Returns the<code>index</code>th item in the collection. If<code>index</code>is greater than or equal to the number of nodes in the list, this returns<code>null</code>.</p></descr><parameters><param name="index" type="unsigned long" attr="in"><descr><p>Index into the collection.</p></descr></param></parameters><returns type="Node"><descr><p>The node at the<code>index</code>th position in the<code>NodeList</code>, or<code>null</code>if that is not a valid index.</p></descr></returns><raises></raises></method><attribute type="unsigned long" readonly="yes" name="length" id="ID-203510337"><descr><p>The number of nodes in the list. The range of valid child node indices is 0 to<code>length-1</code>inclusive.</p></descr></attribute></interface> |
| <interface name="NamedNodeMap" id="ID-1780488922"><descr><p>Objects implementing the<code>NamedNodeMap</code>interface are used to represent collections of nodes that can be accessed by name. Note that<code>NamedNodeMap</code>does not inherit from<code>NodeList</code>;<code>NamedNodeMaps</code>are not maintained in any particular order. Objects contained in an object implementing<code>NamedNodeMap</code>may also be accessed by an ordinal index, but this is simply to allow convenient enumeration of the contents of a<code>NamedNodeMap</code>, and does not imply that the DOM specifies an order to these Nodes.</p><p><code>NamedNodeMap</code>objects in the DOM are<termref def="td-live">live</termref>.</p></descr><method name="getNamedItem" id="ID-1074577549"><descr><p>Retrieves a node specified by name.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The<code>nodeName</code>of a node to retrieve.</p></descr></param></parameters><returns type="Node"><descr><p>A<code>Node</code>(of any type) with the specified<code>nodeName</code>, or<code>null</code>if it does not identify any node in this map.</p></descr></returns><raises></raises></method><method name="setNamedItem" id="ID-1025163788"><descr><p>Adds a node using its<code>nodeName</code>attribute. If a node with that name is already present in this map, it is replaced by the new one. Replacing a node by itself has no effect.</p><p>As the<code>nodeName</code>attribute is used to derive the name which the node must be stored under, multiple nodes of certain types (those that have a "special" string value) cannot be stored as the names would clash. This is seen as preferable to allowing nodes to be aliased.</p></descr><parameters><param name="arg" type="Node" attr="in"><descr><p>A node to store in this map. The node will later be accessible using the value of its<code>nodeName</code>attribute.</p></descr></param></parameters><returns type="Node"><descr><p>If the new<code>Node</code>replaces an existing node the replaced<code>Node</code>is returned, otherwise<code>null</code>is returned.</p></descr></returns><raises><exception name="DOMException"><descr><p>WRONG_DOCUMENT_ERR: Raised if<code>arg</code>was created from a different document than the one that created this map.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.</p><p>INUSE_ATTRIBUTE_ERR: Raised if<code>arg</code>is an<code>Attr</code>that is already an attribute of another<code>Element</code>object. The DOM user must explicitly clone<code>Attr</code>nodes to re-use them in other elements.</p><p>HIERARCHY_REQUEST_ERR: Raised if an attempt is made to add a node doesn't belong in this NamedNodeMap. Examples would include trying to insert something other than an Attr node into an Element's map of attributes, or a non-Entity node into the DocumentType's map of Entities.</p></descr></exception></raises></method><method name="removeNamedItem" id="ID-D58B193"><descr><p>Removes a node specified by name. When this map contains the attributes attached to an element, if the removed attribute is known to have a default value, an attribute immediately appears containing the default value as well as the corresponding namespace URI, local name, and prefix when applicable.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The<code>nodeName</code>of the node to remove.</p></descr></param></parameters><returns type="Node"><descr><p>The node removed from this map if a node with such a name exists.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_FOUND_ERR: Raised if there is no node named<code>name</code>in this map.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.</p></descr></exception></raises></method><method name="item" id="ID-349467F9"><descr><p>Returns the<code>index</code>th item in the map. If<code>index</code>is greater than or equal to the number of nodes in this map, this returns<code>null</code>.</p></descr><parameters><param name="index" type="unsigned long" attr="in"><descr><p>Index into this map.</p></descr></param></parameters><returns type="Node"><descr><p>The node at the<code>index</code>th position in the map, or<code>null</code>if that is not a valid index.</p></descr></returns><raises></raises></method><attribute type="unsigned long" readonly="yes" name="length" id="ID-6D0FB19E"><descr><p>The number of nodes in this map. The range of valid child node indices is<code>0</code>to<code>length-1</code>inclusive.</p></descr></attribute><method name="getNamedItemNS" id="ID-getNamedItemNS" since="DOM Level 2"><descr><p>Retrieves a node specified by local name and namespace URI.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value null as the namespaceURI parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the node to retrieve.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the node to retrieve.</p></descr></param></parameters><returns type="Node"><descr><p>A<code>Node</code>(of any type) with the specified local name and namespace URI, or<code>null</code>if they do not identify any node in this map.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature "XML" and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><method name="setNamedItemNS" id="ID-setNamedItemNS" since="DOM Level 2"><descr><p>Adds a node using its<code>namespaceURI</code>and<code>localName</code>. If a node with that namespace URI and that local name is already present in this map, it is replaced by the new one. Replacing a node by itself has no effect.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value null as the namespaceURI parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="arg" type="Node" attr="in"><descr><p>A node to store in this map. The node will later be accessible using the value of its<code>namespaceURI</code>and<code>localName</code>attributes.</p></descr></param></parameters><returns type="Node"><descr><p>If the new<code>Node</code>replaces an existing node the replaced<code>Node</code>is returned, otherwise<code>null</code>is returned.</p></descr></returns><raises><exception name="DOMException"><descr><p>WRONG_DOCUMENT_ERR: Raised if<code>arg</code>was created from a different document than the one that created this map.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.</p><p>INUSE_ATTRIBUTE_ERR: Raised if<code>arg</code>is an<code>Attr</code>that is already an attribute of another<code>Element</code>object. The DOM user must explicitly clone<code>Attr</code>nodes to re-use them in other elements.</p><p>HIERARCHY_REQUEST_ERR: Raised if an attempt is made to add a node doesn't belong in this NamedNodeMap. Examples would include trying to insert something other than an Attr node into an Element's map of attributes, or a non-Entity node into the DocumentType's map of Entities.</p><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature "XML" and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><method name="removeNamedItemNS" id="ID-removeNamedItemNS" since="DOM Level 2"><descr><p>Removes a node specified by local name and namespace URI. A removed attribute may be known to have a default value when this map contains the attributes attached to an element, as returned by the attributes attribute of the<code>Node</code>interface. If so, an attribute immediately appears containing the default value as well as the corresponding namespace URI, local name, and prefix when applicable.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value null as the namespaceURI parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the node to remove.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the node to remove.</p></descr></param></parameters><returns type="Node"><descr><p>The node removed from this map if a node with such a local name and namespace URI exists.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_FOUND_ERR: Raised if there is no node with the specified<code>namespaceURI</code>and<code>localName</code>in this map.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.</p><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature "XML" and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method></interface> |
| <interface name="CharacterData" inherits="Node" id="ID-FF21A306"><descr><p>The<code>CharacterData</code>interface extends Node with a set of attributes and methods for accessing character data in the DOM. For clarity this set is defined here rather than on each object that uses these attributes and methods. No DOM objects correspond directly to<code>CharacterData</code>, though<code>Text</code>and others do inherit the interface from it. All<code>offsets</code>in this interface start from<code>0</code>.</p><p>As explained in the<code>DOMString</code>interface, text strings in the DOM are represented in UTF-16, i.e. as a sequence of 16-bit units. In the following, the term<termref def="dt-16-bit-unit">16-bit units</termref>is used whenever necessary to indicate that indexing on CharacterData is done in 16-bit units.</p></descr><attribute type="DOMString" name="data" id="ID-72AB8359" readonly="no"><descr><p>The character data of the node that implements this interface. The DOM implementation may not put arbitrary limits on the amount of data that may be stored in a<code>CharacterData</code>node. However, implementation limits may mean that the entirety of a node's data may not fit into a single<code>DOMString</code>. In such cases, the user may call<code>substringData</code>to retrieve the data in appropriately sized pieces.</p></descr><setraises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p></descr></exception></setraises><getraises><exception name="DOMException"><descr><p>DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a<code>DOMString</code>variable on the implementation platform.</p></descr></exception></getraises></attribute><attribute type="unsigned long" name="length" readonly="yes" id="ID-7D61178C"><descr><p>The number of<termref def="dt-16-bit-unit">16-bit units</termref>that are available through<code>data</code>and the<code>substringData</code>method below. This may have the value zero, i.e.,<code>CharacterData</code>nodes may be empty.</p></descr></attribute><method name="substringData" id="ID-6531BCCF"><descr><p>Extracts a range of data from the node.</p></descr><parameters><param name="offset" type="unsigned long" attr="in"><descr><p>Start offset of substring to extract.</p></descr></param><param name="count" type="unsigned long" attr="in"><descr><p>The number of 16-bit units to extract.</p></descr></param></parameters><returns type="DOMString"><descr><p>The specified substring. If the sum of<code>offset</code>and<code>count</code>exceeds the<code>length</code>, then all 16-bit units to the end of the data are returned.</p></descr></returns><raises><exception name="DOMException"><descr><p>INDEX_SIZE_ERR: Raised if the specified<code>offset</code>is negative or greater than the number of 16-bit units in<code>data</code>, or if the specified<code>count</code>is negative.</p><p>DOMSTRING_SIZE_ERR: Raised if the specified range of text does not fit into a<code>DOMString</code>.</p></descr></exception></raises></method><method name="appendData" id="ID-32791A2F"><descr><p>Append the string to the end of the character data of the node. Upon success,<code>data</code>provides access to the concatenation of<code>data</code>and the<code>DOMString</code>specified.</p></descr><parameters><param name="arg" type="DOMString" attr="in"><descr><p>The<code>DOMString</code>to append.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="insertData" id="ID-3EDB695F"><descr><p>Insert a string at the specified<termref def="dt-16-bit-unit">16-bit unit</termref>offset.</p></descr><parameters><param name="offset" type="unsigned long" attr="in"><descr><p>The character offset at which to insert.</p></descr></param><param name="arg" type="DOMString" attr="in"><descr><p>The<code>DOMString</code>to insert.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>INDEX_SIZE_ERR: Raised if the specified<code>offset</code>is negative or greater than the number of 16-bit units in<code>data</code>.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="deleteData" id="ID-7C603781"><descr><p>Remove a range of<termref def="dt-16-bit-unit">16-bit units</termref>from the node. Upon success,<code>data</code>and<code>length</code>reflect the change.</p></descr><parameters><param name="offset" type="unsigned long" attr="in"><descr><p>The offset from which to start removing.</p></descr></param><param name="count" type="unsigned long" attr="in"><descr><p>The number of 16-bit units to delete. If the sum of<code>offset</code>and<code>count</code>exceeds<code>length</code>then all 16-bit units from<code>offset</code>to the end of the data are deleted.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>INDEX_SIZE_ERR: Raised if the specified<code>offset</code>is negative or greater than the number of 16-bit units in<code>data</code>, or if the specified<code>count</code>is negative.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="replaceData" id="ID-E5CBA7FB"><descr><p>Replace the characters starting at the specified<termref def="dt-16-bit-unit">16-bit unit</termref>offset with the specified string.</p></descr><parameters><param name="offset" type="unsigned long" attr="in"><descr><p>The offset from which to start replacing.</p></descr></param><param name="count" type="unsigned long" attr="in"><descr><p>The number of 16-bit units to replace. If the sum of<code>offset</code>and<code>count</code>exceeds<code>length</code>, then all 16-bit units to the end of the data are replaced; (i.e., the effect is the same as a<code>remove</code>method call with the same range, followed by an<code>append</code>method invocation).</p></descr></param><param name="arg" type="DOMString" attr="in"><descr><p>The<code>DOMString</code>with which the range must be replaced.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>INDEX_SIZE_ERR: Raised if the specified<code>offset</code>is negative or greater than the number of 16-bit units in<code>data</code>, or if the specified<code>count</code>is negative.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method></interface> |
| <interface name="Attr" inherits="Node" id="ID-637646024"><descr><p>The<code>Attr</code>interface represents an attribute in an<code>Element</code>object. Typically the allowable values for the attribute are defined in a schema associated with the document.</p><p><code>Attr</code>objects inherit the<code>Node</code>interface, but since they are not actually child nodes of the element they describe, the DOM does not consider them part of the document tree. Thus, the<code>Node</code>attributes<code>parentNode</code>,<code>previousSibling</code>, and<code>nextSibling</code>have a<code>null</code>value for<code>Attr</code>objects. The DOM takes the view that attributes are properties of elements rather than having a separate identity from the elements they are associated with; this should make it more efficient to implement such features as default attributes associated with all elements of a given type. Furthermore,<code>Attr</code>nodes may not be immediate children of a<code>DocumentFragment</code>. However, they can be associated with<code>Element</code>nodes contained within a<code>DocumentFragment</code>. In short, users and implementors of the DOM need to be aware that<code>Attr</code>nodes have some things in common with other objects inheriting the<code>Node</code>interface, but they also are quite distinct.</p><p>The attribute's effective value is determined as follows: if this attribute has been explicitly assigned any value, that value is the attribute's effective value; otherwise, if there is a declaration for this attribute, and that declaration includes a default value, then that default value is the attribute's effective value; otherwise, the attribute does not exist on this element in the structure model until it has been explicitly added. Note that the<code>Node.nodeValue</code>attribute on the<code>Attr</code>instance can also be used to retrieve the string version of the attribute's value(s).</p><p>If the attribute was not explicitly given a value in the instance document but has a default value provided by the schema associated with the document, an attribute node will be created with<code>specified</code>set to<code>false</code>. Removing attribute nodes for which a default value is defined in the schema generates a new attribute node with the default value and<code>specified</code>set to<code>false</code>. If validation occurred while invoking<code>Document.normalizeDocument()</code>, attribute nodes with<code>specified</code>equals to<code>false</code>are recomputed according to the default attribute values provided by the schema. If no default value is associate with this attribute in the schema, the attribute node is discarded.</p><p>In XML, where the value of an attribute can contain entity references, the child nodes of the<code>Attr</code>node may be either<code>Text</code>or<code>EntityReference</code>nodes (when these are in use; see the description of<code>EntityReference</code>for discussion).</p><p>The DOM Core represents all attribute values as simple strings, even if the DTD or schema associated with the document declares them of some specific type such as<termref def="dt-tokenized">tokenized</termref>.</p><p>The way attribute value normalization is performed by the DOM implementation depends on how much the implementation knows about the schema in use. Typically, the<code>value</code>and<code>nodeValue</code>attributes of an<code>Attr</code>node initially returns the normalized value given by the parser. It is also the case after<code>Document.normalizeDocument()</code>is called (assuming the right options have been set). But this may not be the case after mutation, independently of whether the mutation is performed by setting the string value directly or by changing the<code>Attr</code>child nodes. In particular, this is true when<xspecref href="http://www.w3.org/TR/2004/REC-xml-20040204#dt-charref" type="simple" show="new" actuate="onRequest">character references</xspecref>are involved, given that they are not represented in the DOM and they impact attribute value normalization. On the other hand, if the implementation knows about the schema in use when the attribute value is changed, and it is of a different type than CDATA, it may normalize it again at that time. This is especially true of specialized DOM implementations, such as SVG DOM implementations, which store attribute values in an internal form different from a string.</p><p>The following table gives some examples of the relations between the attribute value in the original document (parsed attribute), the value as exposed in the DOM, and the serialization of the value:</p><table cellpadding="3" border="1" summary="Examples of differences between a parsed attribute, its DOM representation, and its serialization"><tbody><tr><th rowspan="1" colspan="1">Examples</th><th rowspan="1" colspan="1">Parsed attribute value</th><th rowspan="1" colspan="1">Initial<code>Attr.value</code></th><th rowspan="1" colspan="1">Serialized attribute value</th></tr><tr><td rowspan="1" colspan="1">Character reference</td><td rowspan="1" colspan="1"><eg space="preserve">"x&#178;=5"</eg></td><td rowspan="1" colspan="1"><eg space="preserve">"x²=5"</eg></td><td rowspan="1" colspan="1"><eg space="preserve">"x&#178;=5"</eg></td></tr><tr><td rowspan="1" colspan="1">Built-in character entity</td><td rowspan="1" colspan="1"><eg space="preserve">"y&lt;6"</eg></td><td rowspan="1" colspan="1"><eg space="preserve">"y<6"</eg></td><td rowspan="1" colspan="1"><eg space="preserve">"y&lt;6"</eg></td></tr><tr><td rowspan="1" colspan="1">Literal newline between</td><td rowspan="1" colspan="1"><eg space="preserve">"x=5&#10;y=6"</eg></td><td rowspan="1" colspan="1"><eg space="preserve">"x=5 y=6"</eg></td><td rowspan="1" colspan="1"><eg space="preserve">"x=5&#10;y=6"</eg></td></tr><tr><td rowspan="1" colspan="1">Normalized newline between</td><td rowspan="1" colspan="1"><eg space="preserve">"x=5 y=6"</eg></td><td rowspan="1" colspan="1"><eg space="preserve">"x=5 y=6"</eg></td><td rowspan="1" colspan="1"><eg space="preserve">"x=5 y=6"</eg></td></tr><tr><td rowspan="1" colspan="1">Entity<code>e</code>with literal newline</td><td rowspan="1" colspan="1"><eg space="preserve"><!ENTITY e '...&#10;...'> [...]> "x=5&e;y=6"</eg></td><td rowspan="1" colspan="1"><emph>Dependent on Implementation and Load Options</emph></td><td rowspan="1" colspan="1"><emph>Dependent on Implementation and Load/Save Options</emph></td></tr></tbody></table></descr><attribute type="DOMString" readonly="yes" name="name" id="ID-1112119403"><descr><p>Returns the name of this attribute. If<code>Node.localName</code>is different from<code>null</code>, this attribute is a<termref def="dt-qualifiedname">qualified name</termref>.</p></descr></attribute><attribute type="boolean" readonly="yes" name="specified" id="ID-862529273"><descr><p><code>True</code>if this attribute was explicitly given a value in the instance document,<code>false</code>otherwise. If the application changed the value of this attribute node (even if it ends up having the same value as the default value) then it is set to<code>true</code>. The implementation may handle attributes with default values from other schemas similarly but applications should use<code>Document.normalizeDocument()</code>to guarantee this information is up-to-date.</p></descr></attribute><attribute type="DOMString" name="value" id="ID-221662474" readonly="no"><descr><p>On retrieval, the value of the attribute is returned as a string. Character and general entity references are replaced with their values. See also the method<code>getAttribute</code>on the<code>Element</code>interface.</p><p>On setting, this creates a<code>Text</code>node with the unparsed contents of the string, i.e. any characters that an XML processor would recognize as markup are instead treated as literal text. See also the method<code>Element.setAttribute()</code>.</p><p>Some specialized implementations, such as some<bibref ref="SVG1" role="informative"/>implementations, may do normalization automatically, even after mutation; in such case, the value on retrieval may differ from the value on setting.</p></descr><setraises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p></descr></exception></setraises></attribute><attribute name="ownerElement" type="Element" readonly="yes" id="Attr-ownerElement" since="DOM Level 2"><descr><p>The<code>Element</code>node this attribute is attached to or<code>null</code>if this attribute is not in use.</p></descr></attribute><attribute name="schemaTypeInfo" type="TypeInfo" id="Attr-schemaTypeInfo" since="DOM Level 3" readonly="yes"><descr><p>The type information associated with this attribute. While the type information contained in this attribute is guarantee to be correct after loading the document or invoking<code>Document.normalizeDocument()</code>,<code>schemaTypeInfo</code>may not be reliable if the node was moved.</p></descr></attribute><attribute name="isId" id="Attr-isId" since="DOM Level 3" readonly="yes" type="boolean"><descr><p>Returns whether this attribute is known to be of type ID (i.e. to contain an identifier for its owner element) or not. When it is and its value is unique, the<code>ownerElement</code>of this attribute can be retrieved using the method<code>Document.getElementById</code>. The implementation could use several ways to determine if an attribute node is known to contain an identifier:</p><ulist><item><p>If validation occurred using an XML Schema<bibref ref="XMLSchema1"/>while loading the document or while invoking<code>Document.normalizeDocument()</code>, the post-schema-validation infoset contributions (PSVI contributions) values are used to determine if this attribute is a<term>schema-determined ID attribute</term>using the<loc href="http://www.w3.org/TR/2003/REC-xptr-framework-20030325/#term-sdi" type="simple" show="replace" actuate="onRequest">schema-determined ID</loc>definition in<bibref ref="XPointer"/>.</p></item><item><p>If validation occurred using a DTD while loading the document or while invoking<code>Document.normalizeDocument()</code>, the infoset<b>[type definition]</b>value is used to determine if this attribute is a<term>DTD-determined ID attribute</term>using the<loc href="http://www.w3.org/TR/2003/REC-xptr-framework-20030325/#term-ddi" type="simple" show="replace" actuate="onRequest">DTD-determined ID</loc>definition in<bibref ref="XPointer"/>.</p></item><item><p>from the use of the methods<code>Element.setIdAttribute()</code>,<code>Element.setIdAttributeNS()</code>, or<code>Element.setIdAttributeNode()</code>, i.e. it is an<term>user-determined ID attribute</term>;</p><note><p>XPointer framework (see section 3.2 in<bibref role="informative" ref="XPointer"/>) consider the DOM<term>user-determined ID attribute</term>as being part of the XPointer<term>externally-determined ID</term>definition.</p></note></item><item><p>using mechanisms that are outside the scope of this specification, it is then an<term>externally-determined ID attribute</term>. This includes using schema languages different from XML schema and DTD.</p></item></ulist><p>If validation occurred while invoking<code>Document.normalizeDocument()</code>, all<term>user-determined ID attributes</term>are reset and all attribute nodes ID information are then reevaluated in accordance to the schema used. As a consequence, if the<code>Attr.schemaTypeInfo</code>attribute contains an ID type,<code>isId</code>will always return true.</p></descr></attribute></interface> |
| <interface name="Element" inherits="Node" id="ID-745549614"><descr><p>The<code>Element</code>interface represents an<termref def="dt-element">element</termref>in an HTML or XML document. Elements may have attributes associated with them; since the<code>Element</code>interface inherits from<code>Node</code>, the generic<code>Node</code>interface attribute<code>attributes</code>may be used to retrieve the set of all attributes for an element. There are methods on the<code>Element</code>interface to retrieve either an<code>Attr</code>object by name or an attribute value by name. In XML, where an attribute value may contain entity references, an<code>Attr</code>object should be retrieved to examine the possibly fairly complex sub-tree representing the attribute value. On the other hand, in HTML, where all attributes have simple string values, methods to directly access an attribute value can safely be used as a<termref def="dt-convenience">convenience</termref>.</p><note><p>In DOM Level 2, the method<code>normalize</code>is inherited from the<code>Node</code>interface where it was moved.</p></note></descr><attribute type="DOMString" name="tagName" readonly="yes" id="ID-104682815"><descr><p>The name of the element. If<code>Node.localName</code>is different from<code>null</code>, this attribute is a<termref def="dt-qualifiedname">qualified name</termref>. For example, in:<eg role="code" space="preserve"><elementExample id="demo"> ... </elementExample> ,</eg><code>tagName</code>has the value<code>"elementExample"</code>. Note that this is case-preserving in XML, as are all of the operations of the DOM. The HTML DOM returns the<code>tagName</code>of an HTML element in the canonical uppercase form, regardless of the case in the source HTML document.</p></descr></attribute><method name="getAttribute" id="ID-666EE0F9"><descr><p>Retrieves an attribute value by name.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute to retrieve.</p></descr></param></parameters><returns type="DOMString"><descr><p>The<code>Attr</code>value as a string, or the empty string if that attribute does not have a specified or default value.</p></descr></returns><raises></raises></method><method name="setAttribute" id="ID-F68F082"><descr><p>Adds a new attribute. If an attribute with that name is already present in the element, its value is changed to be that of the value parameter. This value is a simple string; it is not parsed as it is being set. So any markup (such as syntax to be recognized as an entity reference) is treated as literal text, and needs to be appropriately escaped by the implementation when it is written out. In order to assign an attribute value that contains entity references, the user must create an<code>Attr</code>node plus any<code>Text</code>and<code>EntityReference</code>nodes, build the appropriate subtree, and use<code>setAttributeNode</code>to assign it as the value of an attribute.</p><p>To set an attribute with a qualified name and namespace URI, use the<code>setAttributeNS</code>method.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute to create or alter.</p></descr></param><param name="value" type="DOMString" attr="in"><descr><p>Value to set in string form.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified name is not an XML name according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="removeAttribute" id="ID-6D6AC0F9"><descr><p>Removes an attribute by name. If a default value for the removed attribute is defined in the DTD, a new attribute immediately appears with the default value as well as the corresponding namespace URI, local name, and prefix when applicable. The implementation may handle default values from other schemas similarly but applications should use<code>Document.normalizeDocument()</code>to guarantee this information is up-to-date.</p><p>If no attribute with this name is found, this method has no effect.</p><p>To remove an attribute by local name and namespace URI, use the<code>removeAttributeNS</code>method.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute to remove.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><method name="getAttributeNode" id="ID-217A91B8"><descr><p>Retrieves an attribute node by name.</p><p>To retrieve an attribute node by qualified name and namespace URI, use the<code>getAttributeNodeNS</code>method.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name (<code>nodeName</code>) of the attribute to retrieve.</p></descr></param></parameters><returns type="Attr"><descr><p>The<code>Attr</code>node with the specified name (<code>nodeName</code>) or<code>null</code>if there is no such attribute.</p></descr></returns><raises></raises></method><method name="setAttributeNode" id="ID-887236154"><descr><p>Adds a new attribute node. If an attribute with that name (<code>nodeName</code>) is already present in the element, it is replaced by the new one. Replacing an attribute node by itself has no effect.</p><p>To add a new attribute node with a qualified name and namespace URI, use the<code>setAttributeNodeNS</code>method.</p></descr><parameters><param name="newAttr" type="Attr" attr="in"><descr><p>The<code>Attr</code>node to add to the attribute list.</p></descr></param></parameters><returns type="Attr"><descr><p>If the<code>newAttr</code>attribute replaces an existing attribute, the replaced<code>Attr</code>node is returned, otherwise<code>null</code>is returned.</p></descr></returns><raises><exception name="DOMException"><descr><p>WRONG_DOCUMENT_ERR: Raised if<code>newAttr</code>was created from a different document than the one that created the element.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>INUSE_ATTRIBUTE_ERR: Raised if<code>newAttr</code>is already an attribute of another<code>Element</code>object. The DOM user must explicitly clone<code>Attr</code>nodes to re-use them in other elements.</p></descr></exception></raises></method><method name="removeAttributeNode" id="ID-D589198"><descr><p>Removes the specified attribute node. If a default value for the removed<code>Attr</code>node is defined in the DTD, a new node immediately appears with the default value as well as the corresponding namespace URI, local name, and prefix when applicable. The implementation may handle default values from other schemas similarly but applications should use<code>Document.normalizeDocument()</code>to guarantee this information is up-to-date.</p></descr><parameters><param name="oldAttr" type="Attr" attr="in"><descr><p>The<code>Attr</code>node to remove from the attribute list.</p></descr></param></parameters><returns type="Attr"><descr><p>The<code>Attr</code>node that was removed.</p></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NOT_FOUND_ERR: Raised if<code>oldAttr</code>is not an attribute of the element.</p></descr></exception></raises></method><method name="getElementsByTagName" id="ID-1938918D"><descr><p>Returns a<code>NodeList</code>of all<termref def="dt-descendant">descendant</termref><code>Elements</code>with a given tag name, in<termref def="dt-document-order">document order</termref>.</p></descr><parameters><param name="tagname" type="DOMString" attr="in"><descr><p>The name of the tag to match on. The special value "*" matches all tags.</p></descr></param></parameters><returns type="NodeList"><descr><p>A list of matching<code>Element</code>nodes.</p></descr></returns><raises></raises></method><method name="getAttributeNS" id="ID-ElGetAttrNS" since="DOM Level 2"><descr><p>Retrieves an attribute value by local name and namespace URI.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value<code>null</code>as the<code>namespaceURI</code>parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to retrieve.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the attribute to retrieve.</p></descr></param></parameters><returns type="DOMString"><descr><p>The<code>Attr</code>value as a string, or the empty string if that attribute does not have a specified or default value.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature<code>"XML"</code>and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><method name="setAttributeNS" id="ID-ElSetAttrNS" since="DOM Level 2"><descr><p>Adds a new attribute. If an attribute with the same local name and namespace URI is already present on the element, its prefix is changed to be the prefix part of the<code>qualifiedName</code>, and its value is changed to be the<code>value</code>parameter. This value is a simple string; it is not parsed as it is being set. So any markup (such as syntax to be recognized as an entity reference) is treated as literal text, and needs to be appropriately escaped by the implementation when it is written out. In order to assign an attribute value that contains entity references, the user must create an<code>Attr</code>node plus any<code>Text</code>and<code>EntityReference</code>nodes, build the appropriate subtree, and use<code>setAttributeNodeNS</code>or<code>setAttributeNode</code>to assign it as the value of an attribute.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value<code>null</code>as the<code>namespaceURI</code>parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to create or alter.</p></descr></param><param name="qualifiedName" type="DOMString" attr="in"><descr><p>The<termref def="dt-qualifiedname">qualified name</termref>of the attribute to create or alter.</p></descr></param><param name="value" type="DOMString" attr="in"><descr><p>The value to set in string form.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>INVALID_CHARACTER_ERR: Raised if the specified qualified name is not an XML name according to the XML version in use specified in the<code>Document.xmlVersion</code>attribute.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NAMESPACE_ERR: Raised if the<code>qualifiedName</code>is malformed per the Namespaces in XML specification, if the<code>qualifiedName</code>has a prefix and the<code>namespaceURI</code>is<code>null</code>, if the<code>qualifiedName</code>has a prefix that is "xml" and the<code>namespaceURI</code>is different from "<loc href="http://www.w3.org/XML/1998/namespace" type="simple" show="replace" actuate="onRequest">http://www.w3.org/XML/1998/namespace</loc>", if the<code>qualifiedName</code>or its prefix is "xmlns" and the<code>namespaceURI</code>is different from "<loc href="http://www.w3.org/2000/xmlns/" type="simple" show="replace" actuate="onRequest">http://www.w3.org/2000/xmlns/</loc>", or if the<code>namespaceURI</code>is "<loc href="http://www.w3.org/2000/xmlns/" type="simple" show="replace" actuate="onRequest">http://www.w3.org/2000/xmlns/</loc>" and neither the<code>qualifiedName</code>nor its prefix is "xmlns".</p><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature<code>"XML"</code>and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><method name="removeAttributeNS" id="ID-ElRemAtNS" since="DOM Level 2"><descr><p>Removes an attribute by local name and namespace URI. If a default value for the removed attribute is defined in the DTD, a new attribute immediately appears with the default value as well as the corresponding namespace URI, local name, and prefix when applicable. The implementation may handle default values from other schemas similarly but applications should use<code>Document.normalizeDocument()</code>to guarantee this information is up-to-date.</p><p>If no attribute with this local name and namespace URI is found, this method has no effect.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value<code>null</code>as the<code>namespaceURI</code>parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to remove.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the attribute to remove.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature<code>"XML"</code>and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><method name="getAttributeNodeNS" id="ID-ElGetAtNodeNS" since="DOM Level 2"><descr><p>Retrieves an<code>Attr</code>node by local name and namespace URI.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value<code>null</code>as the<code>namespaceURI</code>parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to retrieve.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the attribute to retrieve.</p></descr></param></parameters><returns type="Attr"><descr><p>The<code>Attr</code>node with the specified attribute local name and namespace URI or<code>null</code>if there is no such attribute.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature<code>"XML"</code>and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><method name="setAttributeNodeNS" id="ID-ElSetAtNodeNS" since="DOM Level 2"><descr><p>Adds a new attribute. If an attribute with that local name and that namespace URI is already present in the element, it is replaced by the new one. Replacing an attribute node by itself has no effect.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value<code>null</code>as the<code>namespaceURI</code>parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="newAttr" type="Attr" attr="in"><descr><p>The<code>Attr</code>node to add to the attribute list.</p></descr></param></parameters><returns type="Attr"><descr><p>If the<code>newAttr</code>attribute replaces an existing attribute with the same<termref def="dt-localname">local name</termref>and<termref def="dt-namespaceURI">namespace URI</termref>, the replaced<code>Attr</code>node is returned, otherwise<code>null</code>is returned.</p></descr></returns><raises><exception name="DOMException"><descr><p>WRONG_DOCUMENT_ERR: Raised if<code>newAttr</code>was created from a different document than the one that created the element.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>INUSE_ATTRIBUTE_ERR: Raised if<code>newAttr</code>is already an attribute of another<code>Element</code>object. The DOM user must explicitly clone<code>Attr</code>nodes to re-use them in other elements.</p><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature<code>"XML"</code>and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><method name="getElementsByTagNameNS" id="ID-A6C90942" since="DOM Level 2"><descr><p>Returns a<code>NodeList</code>of all the<termref def="dt-descendant">descendant</termref><code>Elements</code>with a given local name and namespace URI in<termref def="dt-document-order">document order</termref>.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the elements to match on. The special value "*" matches all namespaces.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the elements to match on. The special value "*" matches all local names.</p></descr></param></parameters><returns type="NodeList"><descr><p>A new<code>NodeList</code>object containing all the matched<code>Elements</code>.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature<code>"XML"</code>and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><method name="hasAttribute" id="ID-ElHasAttr" since="DOM Level 2"><descr><p>Returns<code>true</code>when an attribute with a given name is specified on this element or has a default value,<code>false</code>otherwise.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute to look for.</p></descr></param></parameters><returns type="boolean"><descr><p><code>true</code>if an attribute with the given name is specified on this element or has a default value,<code>false</code>otherwise.</p></descr></returns><raises></raises></method><method name="hasAttributeNS" id="ID-ElHasAttrNS" since="DOM Level 2"><descr><p>Returns<code>true</code>when an attribute with a given local name and namespace URI is specified on this element or has a default value,<code>false</code>otherwise.</p><p>Per<bibref ref="Namespaces"/>, applications must use the value<code>null</code>as the<code>namespaceURI</code>parameter for methods if they wish to have no namespace.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute to look for.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the attribute to look for.</p></descr></param></parameters><returns type="boolean"><descr><p><code>true</code>if an attribute with the given local name and namespace URI is specified or has a default value on this element,<code>false</code>otherwise.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_SUPPORTED_ERR: May be raised if the implementation does not support the feature<code>"XML"</code>and the language exposed through the Document does not support XML Namespaces (such as<bibref role="informative" ref="HTML40"/>).</p></descr></exception></raises></method><attribute name="schemaTypeInfo" type="TypeInfo" id="Element-schemaTypeInfo" since="DOM Level 3" readonly="yes"><descr><p>The type information associated with this element.</p></descr></attribute><method name="setIdAttribute" id="ID-ElSetIdAttr" since="DOM Level 3"><descr><p>If the parameter<code>isId</code>is<code>true</code>, this method declares the specified attribute to be a<term>user-determined ID attribute</term>. This affects the value of<code>Attr.isId</code>and the behavior of<code>Document.getElementById</code>, but does not change any schema that may be in use, in particular this does not affect the<code>Attr.schemaTypeInfo</code>of the specified<code>Attr</code>node. Use the value<code>false</code>for the parameter<code>isId</code>to undeclare an attribute for being a<term>user-determined ID attribute</term>.</p><p>To specify an attribute by local name and namespace URI, use the<code>setIdAttributeNS</code>method.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the attribute.</p></descr></param><param name="isId" type="boolean" attr="in"><descr><p>Whether the attribute is a of type ID.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NOT_FOUND_ERR: Raised if the specified node is not an attribute of this element.</p></descr></exception></raises></method><method name="setIdAttributeNS" id="ID-ElSetIdAttrNS" since="DOM Level 3"><descr><p>If the parameter<code>isId</code>is<code>true</code>, this method declares the specified attribute to be a<term>user-determined ID attribute</term>. This affects the value of<code>Attr.isId</code>and the behavior of<code>Document.getElementById</code>, but does not change any schema that may be in use, in particular this does not affect the<code>Attr.schemaTypeInfo</code>of the specified<code>Attr</code>node. Use the value<code>false</code>for the parameter<code>isId</code>to undeclare an attribute for being a<term>user-determined ID attribute</term>.</p></descr><parameters><param name="namespaceURI" type="DOMString" attr="in"><descr><p>The<termref def="dt-namespaceURI">namespace URI</termref>of the attribute.</p></descr></param><param name="localName" type="DOMString" attr="in"><descr><p>The<termref def="dt-localname">local name</termref>of the attribute.</p></descr></param><param name="isId" type="boolean" attr="in"><descr><p>Whether the attribute is a of type ID.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NOT_FOUND_ERR: Raised if the specified node is not an attribute of this element.</p></descr></exception></raises></method><method name="setIdAttributeNode" id="ID-ElSetIdAttrNode" since="DOM Level 3"><descr><p>If the parameter<code>isId</code>is<code>true</code>, this method declares the specified attribute to be a<term>user-determined ID attribute</term>. This affects the value of<code>Attr.isId</code>and the behavior of<code>Document.getElementById</code>, but does not change any schema that may be in use, in particular this does not affect the<code>Attr.schemaTypeInfo</code>of the specified<code>Attr</code>node. Use the value<code>false</code>for the parameter<code>isId</code>to undeclare an attribute for being a<term>user-determined ID attribute</term>.</p></descr><parameters><param name="idAttr" type="Attr" attr="in"><descr><p>The attribute node.</p></descr></param><param name="isId" type="boolean" attr="in"><descr><p>Whether the attribute is a of type ID.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p><p>NOT_FOUND_ERR: Raised if the specified node is not an attribute of this element.</p></descr></exception></raises></method></interface> |
| <interface name="Text" inherits="CharacterData" id="ID-1312295772"><descr><p>The<code>Text</code>interface inherits from<code>CharacterData</code>and represents the textual content (termed<xspecref href="http://www.w3.org/TR/2004/REC-xml-20040204#syntax" type="simple" show="new" actuate="onRequest">character data</xspecref>in XML) of an<code>Element</code>or<code>Attr</code>. If there is no markup inside an element's content, the text is contained in a single object implementing the<code>Text</code>interface that is the only child of the element. If there is markup, it is parsed into the<termref def="dt-infoitem">information items</termref>(elements, comments, etc.) and<code>Text</code>nodes that form the list of children of the element.</p><p>When a document is first made available via the DOM, there is only one<code>Text</code>node for each block of text. Users may create adjacent<code>Text</code>nodes that represent the contents of a given element without any intervening markup, but should be aware that there is no way to represent the separations between these nodes in XML or HTML, so they will not (in general) persist between DOM editing sessions. The<code>Node.normalize()</code>method merges any such adjacent<code>Text</code>objects into a single node for each block of text.</p><p>No lexical check is done on the content of a<code>Text</code>node and, depending on its position in the document, some characters must be escaped during serialization using character references; e.g. the characters "<&" if the textual content is part of an element or of an attribute, the character sequence "]]>" when part of an element, the quotation mark character " or the apostrophe character ' when part of an attribute.</p></descr><method name="splitText" id="ID-38853C1D"><descr><p>Breaks this node into two nodes at the specified<code>offset</code>, keeping both in the tree as<termref def="dt-sibling">siblings</termref>. After being split, this node will contain all the content up to the<code>offset</code>point. A new node of the same type, which contains all the content at and after the<code>offset</code>point, is returned. If the original node had a parent node, the new node is inserted as the next<termref def="dt-sibling">sibling</termref>of the original node. When the<code>offset</code>is equal to the length of this node, the new node has no data.</p></descr><parameters><param name="offset" type="unsigned long" attr="in"><descr><p>The<termref def="dt-16-bit-unit">16-bit unit</termref>offset at which to split, starting from<code>0</code>.</p></descr></param></parameters><returns type="Text"><descr><p>The new node, of the same type as this node.</p></descr></returns><raises><exception name="DOMException"><descr><p>INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of 16-bit units in<code>data</code>.</p><p>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.</p></descr></exception></raises></method><attribute name="isElementContentWhitespace" id="Text3-isElementContentWhitespace" since="DOM Level 3" readonly="yes" type="boolean"><descr><p>Returns whether this text node contains<xspecref href="http://www.w3.org/TR/2004/REC-xml-infoset-20040204#infoitem.character" type="simple" show="new" actuate="onRequest">element content whitespace</xspecref>, often abusively called "ignorable whitespace". The text node is determined to contain whitespace in element content during the load of the document or if validation occurs while using<code>Document.normalizeDocument()</code>.</p></descr></attribute><attribute readonly="yes" type="DOMString" name="wholeText" id="Text3-wholeText" since="DOM Level 3"><descr><p>Returns all text of<code>Text</code>nodes<termref def="dt-logically-adjacent-text-nodes">logically-adjacent text nodes</termref>to this node, concatenated in document order.</p><p>For instance, in the example below<code>wholeText</code>on the<code>Text</code>node that contains "bar" returns "barfoo", while on the<code>Text</code>node that contains "foo" it returns "barfoo".</p><graphic source="./images/wholeTextExmpl.png" alt="barTextNode.wholeText value is "barfoo"" type="simple" show="embed" actuate="onLoad"/></descr></attribute><method name="replaceWholeText" id="Text3-replaceWholeText" since="DOM Level 3"><descr><p>Replaces the text of the current node and all<termref def="dt-logically-adjacent-text-nodes">logically-adjacent text nodes</termref>with the specified text. All<termref def="dt-logically-adjacent-text-nodes">logically-adjacent text nodes</termref>are removed including the current node unless it was the recipient of the replacement text.</p><p>This method returns the node which received the replacement text. The returned node is:</p><ulist><item><p><code>null</code>, when the replacement text is the empty string;</p></item><item><p>the current node, except when the current node is<termref def="dt-readonly-node">read-only</termref>;</p></item><item><p>a new<code>Text</code>node of the same type (<code>Text</code>or<code>CDATASection</code>) as the current node inserted at the location of the replacement.</p></item></ulist><p>For instance, in the above example calling<code>replaceWholeText</code>on the<code>Text</code>node that contains "bar" with "yo" in argument results in the following:</p><graphic source="./images/wholeTextExmpl2.png" alt="barTextNode.replaceWholeText("yo") modifies the textual content of barTextNode with "yo"" type="simple" show="embed" actuate="onLoad"/><p>Where the nodes to be removed are read-only descendants of an<code>EntityReference</code>, the<code>EntityReference</code>must be removed instead of the read-only nodes. If any<code>EntityReference</code>to be removed has descendants that are not<code>EntityReference</code>,<code>Text</code>, or<code>CDATASection</code>nodes, the<code>replaceWholeText</code>method must fail before performing any modification of the document, raising a<code>DOMException</code>with the code<code>NO_MODIFICATION_ALLOWED_ERR</code>.</p><p>For instance, in the example below calling<code>replaceWholeText</code>on the<code>Text</code>node that contains "bar" fails, because the<code>EntityReference</code>node "ent" contains an<code>Element</code>node which cannot be removed.</p><graphic source="./images/wholeTextExmpl3.png" alt="barTextNode.replaceWholeText("yo") raises a NO_MODIFICATION_ALLOWED_ERR DOMException" type="simple" show="embed" actuate="onLoad"/></descr><parameters><param name="content" type="DOMString" attr="in"><descr><p>The content of the replacing<code>Text</code>node.</p></descr></param></parameters><returns type="Text"><descr><p>The<code>Text</code>node created with the specified content.</p></descr></returns><raises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised if one of the<code>Text</code>nodes being replaced is readonly.</p></descr></exception></raises></method></interface> |
| <interface name="Comment" inherits="CharacterData" id="ID-1728279322"><descr><p>This interface inherits from<code>CharacterData</code>and represents the content of a comment, i.e., all the characters between the starting '<code><!--</code>' and ending '<code>--></code>'. Note that this is the definition of a comment in XML, and, in practice, HTML, although some HTML tools may implement the full SGML comment structure.</p><p>No lexical check is done on the content of a comment and it is therefore possible to have the character sequence<code>"--"</code>(double-hyphen) in the content, which is illegal in a comment per section 2.5 of<bibref ref="XML"/>. The presence of this character sequence must generate a fatal error during serialization.</p></descr></interface> |
| <interface name="TypeInfo" id="TypeInfo" since="DOM Level 3"><descr><p>The<code>TypeInfo</code>interface represents a type referenced from<code>Element</code>or<code>Attr</code>nodes, specified in the<termref def="dt-schema">schemas</termref>associated with the document. The type is a pair of a<termref def="dt-namespaceURI">namespace URI</termref>and name properties, and depends on the document's schema.</p><p>If the document's schema is an XML DTD<bibref ref="XML"/>, the values are computed as follows:</p><ulist><item><p>If this type is referenced from an<code>Attr</code>node,<code>typeNamespace</code>is<code>"http://www.w3.org/TR/REC-xml"</code>and<code>typeName</code>represents the<b>[attribute type]</b>property in the<bibref ref="InfoSet"/>. If there is no declaration for the attribute,<code>typeNamespace</code>and<code>typeName</code>are<code>null</code>.</p></item><item><p>If this type is referenced from an<code>Element</code>node,<code>typeNamespace</code>and<code>typeName</code>are<code>null</code>.</p></item></ulist><p>If the document's schema is an XML Schema<bibref ref="XMLSchema1"/>, the values are computed as follows using the post-schema-validation infoset contributions (also called PSVI contributions):</p><ulist><item><p>If the<b>[validity]</b>property exists AND is<emph>"invalid"</emph>or<emph>"notKnown"</emph>: the {target namespace} and {name} properties of the declared type if available, otherwise<code>null</code>.</p><note><p>At the time of writing, the XML Schema specification does not require exposing the declared type. Thus, DOM implementations might choose not to provide type information if validity is not valid.</p></note></item><item><p>If the<b>[validity]</b>property exists and is<emph>"valid"</emph>:</p><olist><item><p>If<b>[member type definition]</b>exists:</p><olist><item><p>If {name} is not absent, then expose {name} and {target namespace} properties of the<b>[member type definition]</b>property;</p></item><item><p>Otherwise, expose the namespace and local name of the corresponding<termref def="dt-anonymous">anonymous type name</termref>.</p></item></olist></item><item><p>If the<b>[type definition]</b>property exists:<olist><item><p>If {name} is not absent, then expose {name} and {target namespace} properties of the<b>[type definition]</b>property;</p></item><item><p>Otherwise, expose the namespace and local name of the corresponding<termref def="dt-anonymous">anonymous type name</termref>.</p></item></olist></p></item><item><p>If the<b>[member type definition anonymous]</b>exists:<olist><item><p>If it is false, then expose<b>[member type definition name]</b>and<b>[member type definition namespace]</b>properties;</p></item><item><p>Otherwise, expose the namespace and local name of the corresponding<termref def="dt-anonymous">anonymous type name</termref>.</p></item></olist></p></item><item><p>If the<b>[type definition anonymous]</b>exists:<olist><item><p>If it is false, then expose<b>[type definition name]</b>and<b>[type definition namespace]</b>properties;</p></item><item><p>Otherwise, expose the namespace and local name of the corresponding<termref def="dt-anonymous">anonymous type name</termref>.</p></item></olist></p></item></olist></item></ulist><note><p>Other schema languages are outside the scope of the W3C and therefore should define how to represent their type systems using<code>TypeInfo</code>.</p></note></descr><attribute name="typeName" type="DOMString" id="TypeInfo-typeName" readonly="yes"><descr><p>The name of a type declared for the associated element or attribute, or<code>null</code>if unknown.</p></descr></attribute><attribute name="typeNamespace" type="DOMString" id="TypeInfo-typeNamespace" readonly="yes"><descr><p>The namespace of the type declared for the associated element or attribute or<code>null</code>if the element does not have declaration or if no namespace information is available.</p></descr></attribute><group name="DerivationMethods" id="TypeInfo-DerivationMethods"><descr><p>These are the available values for the<code>derivationMethod</code>parameter used by the method<code>TypeInfo.isDerivedFrom()</code>. It is a set of possible types of derivation, and the values represent bit positions. If a bit in the<code>derivationMethod</code>parameter is set to<code>1</code>, the corresponding type of derivation will be taken into account when evaluating the derivation between the reference type definition and the other type definition. When using the<code>isDerivedFrom</code>method, combining all of them in the<code>derivationMethod</code>parameter is equivalent to invoking the method for each of them separately and combining the results with the OR boolean function. This specification only defines the type of derivation for XML Schema.</p><p>In addition to the types of derivation listed below, please note that:</p><ulist><item><p>any type derives from<code>xsd:anyType</code>.</p></item><item><p>any simple type derives from<code>xsd:anySimpleType</code>by<term>restriction</term>.</p></item><item><p>any complex type does not derive from<code>xsd:anySimpleType</code>by<term>restriction</term>.</p></item></ulist></descr><constant id="TypeInfo-DERIVATION_RESTRICTION" name="DERIVATION_RESTRICTION" type="unsigned long" value="0x00000001"><descr><p>If the document's schema is an XML Schema<bibref ref="XMLSchema1"/>, this constant represents the derivation by<xspecref href="http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/#key-typeRestriction" type="simple" show="new" actuate="onRequest">restriction</xspecref>if complex types are involved, or a<xspecref href="http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/#element-restriction" type="simple" show="new" actuate="onRequest">restriction</xspecref>if simple types are involved.</p><p><termdef id="id-restriction" term="restriction">The reference type definition is derived by<term>restriction</term>from the other type definition if the other type definition is the same as the reference type definition, or if the other type definition can be reached recursively following the {base type definition} property from the reference type definition, and all the<emph>derivation methods</emph>involved are<term>restriction</term>.</termdef></p></descr></constant><constant id="TypeInfo-DERIVATION_EXTENSION" name="DERIVATION_EXTENSION" type="unsigned long" value="0x00000002"><descr><p>If the document's schema is an XML Schema<bibref ref="XMLSchema1"/>, this constant represents the derivation by<xspecref href="http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/#key-typeExtension" type="simple" show="new" actuate="onRequest">extension</xspecref>.</p><p><termdef id="id-extension" term="extension">The reference type definition is derived by<term>extension</term>from the other type definition if the other type definition can be reached recursively following the {base type definition} property from the reference type definition, and at least one of the<emph>derivation methods</emph>involved is an<term>extension</term>.</termdef></p></descr></constant><constant id="TypeInfo-DERIVATION_UNION" name="DERIVATION_UNION" type="unsigned long" value="0x00000004"><descr><p>If the document's schema is an XML Schema<bibref ref="XMLSchema1"/>, this constant represents the<xspecref href="http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/#element-union" type="simple" show="new" actuate="onRequest">union</xspecref>if simple types are involved.</p><p><termdef id="id-union" term="union">The reference type definition is derived by<term>union</term>from the other type definition if there exists two type definitions T1 and T2 such as the reference type definition is derived from T1 by<code>DERIVATION_RESTRICTION</code>or<code>DERIVATION_EXTENSION</code>, T2 is derived from the other type definition by<code>DERIVATION_RESTRICTION</code>, T1 has {variety}<emph>union</emph>, and one of the {member type definitions} is T2. Note that T1 could be the same as the reference type definition, and T2 could be the same as the other type definition.</termdef></p></descr></constant><constant id="TypeInfo-DERIVATION_LIST" name="DERIVATION_LIST" type="unsigned long" value="0x00000008"><descr><p>If the document's schema is an XML Schema<bibref ref="XMLSchema1"/>, this constant represents the<xspecref href="http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/#element-list" type="simple" show="new" actuate="onRequest">list</xspecref>.</p><p><termdef id="id-list" term="list">The reference type definition is derived by<term>list</term>from the other type definition if there exists two type definitions T1 and T2 such as the reference type definition is derived from T1 by<code>DERIVATION_RESTRICTION</code>or<code>DERIVATION_EXTENSION</code>, T2 is derived from the other type definition by<code>DERIVATION_RESTRICTION</code>, T1 has {variety}<emph>list</emph>, and T2 is the {item type definition}. Note that T1 could be the same as the reference type definition, and T2 could be the same as the other type definition.</termdef></p></descr></constant></group><method name="isDerivedFrom" id="TypeInfo-isDerivedFrom"><descr><p>This method returns if there is a derivation between the reference type definition, i.e. the<code>TypeInfo</code>on which the method is being called, and the other type definition, i.e. the one passed as parameters.</p></descr><parameters><param name="typeNamespaceArg" type="DOMString" attr="in"><descr><p>the namespace of the other type definition.</p></descr></param><param name="typeNameArg" type="DOMString" attr="in"><descr><p>the name of the other type definition.</p></descr></param><param name="derivationMethod" type="unsigned long" attr="in"><descr><p>the type of derivation and conditions applied between two types, as described in the list of constants provided in this interface.</p></descr></param></parameters><returns type="boolean"><descr><p>If the document's schema is a DTD or no schema is associated with the document, this method will always return<code>false</code>.</p><p>If the document's schema is an XML Schema, the method will<code>true</code>if the reference type definition is derived from the other type definition according to the derivation parameter. If the value of the parameter is<code>0</code>(no bit is set to<code>1</code>for the<code>derivationMethod</code>parameter), the method will return<code>true</code>if the other type definition can be reached by recursing any combination of {base type definition}, {item type definition}, or {member type definitions} from the reference type definition.</p></descr></returns><raises></raises></method></interface> |
| <interface name="UserDataHandler" id="UserDataHandler" since="DOM Level 3" role="ecmascript-function"><descr><p>When associating an object to a key on a node using<code>Node.setUserData()</code>the application can provide a handler that gets called when the node the object is associated to is being cloned, imported, or renamed. This can be used by the application to implement various behaviors regarding the data it associates to the DOM nodes. This interface defines that handler.</p></descr><group id="ID-UserDataOperation" name="OperationType"><descr><p>An integer indicating the type of operation being performed on a node.</p></descr><constant id="UserDataHandler-CLONED" name="NODE_CLONED" type="unsigned short" value="1"><descr><p>The node is cloned, using<code>Node.cloneNode()</code>.</p></descr></constant><constant id="UserDataHandler-IMPORTED" name="NODE_IMPORTED" type="unsigned short" value="2"><descr><p>The node is imported, using<code>Document.importNode()</code>.</p></descr></constant><constant id="UserDataHandler-DELETED" name="NODE_DELETED" type="unsigned short" value="3"><descr><p>The node is deleted.</p><note><p>This may not be supported or may not be reliable in certain environments, such as Java, where the implementation has no real control over when objects are actually deleted.</p></note></descr></constant><constant id="UserDataHandler-RENAMED" name="NODE_RENAMED" type="unsigned short" value="4"><descr><p>The node is renamed, using<code>Document.renameNode()</code>.</p></descr></constant><constant id="UserDataHandler-ADOPTED" name="NODE_ADOPTED" type="unsigned short" value="5"><descr><p>The node is adopted, using<code>Document.adoptNode()</code>.</p></descr></constant></group><method name="handle" id="ID-handleUserDataEvent"><descr><p>This method is called whenever the node for which this handler is registered is imported or cloned.</p><p>DOM applications must not raise exceptions in a<code>UserDataHandler</code>. The effect of throwing exceptions from the handler is DOM implementation dependent.</p></descr><parameters><param name="operation" type="unsigned short" attr="in"><descr><p>Specifies the type of operation that is being performed on the node.</p></descr></param><param name="key" type="DOMString" attr="in"><descr><p>Specifies the key for which this handler is being called.</p></descr></param><param name="data" type="DOMUserData" attr="in"><descr><p>Specifies the data for which this handler is being called.</p></descr></param><param name="src" type="Node" attr="in"><descr><p>Specifies the node being cloned, adopted, imported, or renamed. This is<code>null</code>when the node is being deleted.</p></descr></param><param name="dst" type="Node" attr="in"><descr><p>Specifies the node newly created if any, or<code>null</code>.</p></descr></param></parameters><returns type="void"><descr><p/></descr></returns><raises></raises></method></interface> |
| <interface name="DOMError" id="ERROR-Interfaces-DOMError" since="DOM Level 3"><descr><p><code>DOMError</code>is an interface that describes an error.</p></descr><group id="DOMError-errorSeverityCodes" name="ErrorSeverity"><descr><p>An integer indicating the severity of the error.</p></descr><constant name="SEVERITY_WARNING" id="ERROR-DOMError-severity-warning" type="unsigned short" value="1"><descr><p>The severity of the error described by the<code>DOMError</code>is warning. A<code>SEVERITY_WARNING</code>will not cause the processing to stop, unless<code>DOMErrorHandler.handleError()</code>returns<code>false</code>.</p></descr></constant><constant name="SEVERITY_ERROR" id="ERROR-DOMError-severity-error" type="unsigned short" value="2"><descr><p>The severity of the error described by the<code>DOMError</code>is error. A<code>SEVERITY_ERROR</code>may not cause the processing to stop if the error can be recovered, unless<code>DOMErrorHandler.handleError()</code>returns<code>false</code>.</p></descr></constant><constant name="SEVERITY_FATAL_ERROR" id="ERROR-DOMError-severity-fatal-error" type="unsigned short" value="3"><descr><p>The severity of the error described by the<code>DOMError</code>is fatal error. A<code>SEVERITY_FATAL_ERROR</code>will cause the normal processing to stop. The return value of<code>DOMErrorHandler.handleError()</code>is ignored unless the implementation chooses to continue, in which case the behavior becomes undefined.</p></descr></constant></group><attribute type="unsigned short" readonly="yes" name="severity" id="ERROR-DOMError-severity"><descr><p>The severity of the error, either<code>SEVERITY_WARNING</code>,<code>SEVERITY_ERROR</code>, or<code>SEVERITY_FATAL_ERROR</code>.</p></descr></attribute><attribute type="DOMString" readonly="yes" name="message" id="ERROR-DOMError-message"><descr><p>An implementation specific string describing the error that occurred.</p></descr></attribute><attribute name="type" type="DOMString" readonly="yes" id="ERROR-DOMError-type"><descr><p>A<code>DOMString</code>indicating which related data is expected in<code>relatedData</code>. Users should refer to the specification of the error in order to find its<code>DOMString</code>type and<code>relatedData</code>definitions if any.</p><note><p>As an example,<code>Document.normalizeDocument()</code>does generate warnings when the "<termref def="parameter-split-cdata-sections">split-cdata-sections</termref>" parameter is in use. Therefore, the method generates a<code>SEVERITY_WARNING</code>with<code>type</code><code>"cdata-sections-splitted"</code>and the first<code>CDATASection</code>node in document order resulting from the split is returned by the<code>relatedData</code>attribute.</p></note></descr></attribute><attribute type="DOMObject" readonly="yes" name="relatedException" id="ERROR-DOMError-relatedException"><descr><p>The related platform dependent exception if any.</p></descr></attribute><attribute type="DOMObject" readonly="yes" name="relatedData" id="ERROR-DOMError-relatedData"><descr><p>The related<code>DOMError.type</code>dependent data if any.</p></descr></attribute><attribute type="DOMLocator" readonly="yes" name="location" id="ERROR-DOMError-location"><descr><p>The location of the error.</p></descr></attribute></interface> |
| <interface name="DOMErrorHandler" id="ERROR-Interfaces-DOMErrorHandler" since="DOM Level 3" role="ecmascript-function"><descr><p><code>DOMErrorHandler</code>is a callback interface that the DOM implementation can call when reporting errors that happens while processing XML data, or when doing some other processing (e.g. validating a document). A<code>DOMErrorHandler</code>object can be attached to a<code>Document</code>using the "<termref def="parameter-error-handler">error-handler</termref>" on the<code>DOMConfiguration</code>interface. If more than one error needs to be reported during an operation, the sequence and numbers of the errors passed to the error handler are implementation dependent.</p><p>The application that is using the DOM implementation is expected to implement this interface.</p></descr><method name="handleError" id="ID-ERRORS-DOMErrorHandler-handleError"><descr><p>This method is called on the error handler when an error occurs.</p><p>If an exception is thrown from this method, it is considered to be equivalent of returning<code>true</code>.</p></descr><parameters><param name="error" type="DOMError" attr="in"><descr><p>The error object that describes the error. This object may be reused by the DOM implementation across multiple calls to the<code>handleError</code>method.</p></descr></param></parameters><returns type="boolean"><descr><p>If the<code>handleError</code>method returns<code>false</code>, the DOM implementation should stop the current processing when possible. If the method returns<code>true</code>, the processing may continue depending on<code>DOMError.severity</code>.</p></descr></returns><raises></raises></method></interface> |
| <interface name="DOMLocator" id="Interfaces-DOMLocator" since="DOM Level 3"><descr><p><code>DOMLocator</code>is an interface that describes a location (e.g. where an error occurred).</p></descr><attribute type="long" readonly="yes" name="lineNumber" id="DOMLocator-line-number"><descr><p>The line number this locator is pointing to, or<code>-1</code>if there is no column number available.</p></descr></attribute><attribute type="long" readonly="yes" name="columnNumber" id="DOMLocator-column-number"><descr><p>The column number this locator is pointing to, or<code>-1</code>if there is no column number available.</p></descr></attribute><attribute type="long" readonly="yes" name="byteOffset" id="DOMLocator-byteOffset"><descr><p>The byte offset into the input source this locator is pointing to or<code>-1</code>if there is no byte offset available.</p></descr></attribute><attribute type="long" readonly="yes" name="utf16Offset" id="DOMLocator-utf16Offset"><descr><p>The UTF-16, as defined in<bibref ref="Unicode"/>and Amendment 1 of<bibref ref="ISO10646"/>, offset into the input source this locator is pointing to or<code>-1</code>if there is no UTF-16 offset available.</p></descr></attribute><attribute type="Node" readonly="yes" name="relatedNode" id="DOMLocator-node"><descr><p>The node this locator is pointing to, or<code>null</code>if no node is available.</p></descr></attribute><attribute type="DOMString" readonly="yes" name="uri" id="DOMLocator-uri"><descr><p>The URI this locator is pointing to, or<code>null</code>if no URI is available.</p></descr></attribute></interface> |
| <interface name="DOMConfiguration" id="DOMConfiguration" since="DOM Level 3"><descr><p>The<code>DOMConfiguration</code>interface represents the configuration of a document and maintains a table of recognized parameters. Using the configuration, it is possible to change<code>Document.normalizeDocument()</code>behavior, such as replacing the<code>CDATASection</code>nodes with<code>Text</code>nodes or specifying the type of the<termref def="dt-schema">schema</termref>that must be used when the validation of the<code>Document</code>is requested.<code>DOMConfiguration</code>objects are also used in<bibref role="informative" ref="DOMLS"/>in the<code>DOMParser</code>and<code>DOMSerializer</code>interfaces.</p><p>The parameter names used by the<code>DOMConfiguration</code>object are defined throughout the DOM Level 3 specifications. Names are case-insensitive. To avoid possible conflicts, as a convention, names referring to parameters defined outside the DOM specification should be made unique. Because parameters are exposed as properties in the<specref ref="ecma-binding"/>, names are recommended to follow the section<quote>5.16 Identifiers</quote>of<bibref role="informative" ref="Unicode"/>with the addition of the character '-' (HYPHEN-MINUS) but it is not enforced by the DOM implementation. DOM Level 3 Core Implementations are required to recognize all parameters defined in this specification. Some parameter values may also be required to be supported by the implementation. Refer to the definition of the parameter to know if a value must be supported or not.</p><note><p>Parameters are similar to features and properties used in SAX2<bibref role="informative" ref="SAX"/>.</p></note><p>The following list of parameters defined in the DOM:</p><glist><gitem><label id="parameter-canonical-form"><code>"canonical-form"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>optional</emph>]</p><p>Canonicalize the document according to the rules specified in<bibref role="informative" ref="c14n"/>, such as removing the<code>DocumentType</code>node (if any) from the tree, or removing superfluous namespace declarations from each element. Note that this is limited to what can be represented in the DOM; in particular, there is no way to specify the order of the attributes in the DOM. In addition,</p><p>Setting this parameter to<code>true</code>will also set the state of the parameters listed below. Later changes to the state of one of those parameters will revert "<termref def="parameter-canonical-form">canonical-form</termref>" back to<code>false</code>.</p><p>Parameters set to<code>false</code>: "<termref def="parameter-entities">entities</termref>", "<termref def="parameter-normalize-characters">normalize-characters</termref>", "<termref def="parameter-cdata-sections">cdata-sections</termref>".</p><p>Parameters set to<code>true</code>: "<termref def="parameter-namespaces">namespaces</termref>", "<termref def="parameter-namespace-declarations">namespace-declarations</termref>", "<termref def="parameter-well-formed">well-formed</termref>", "<termref def="parameter-element-content-whitespace">element-content-whitespace</termref>".</p><p>Other parameters are not changed unless explicitly specified in the description of the parameters.</p></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Do not canonicalize the document.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-cdata-sections"><code>"cdata-sections"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Keep<code>CDATASection</code>nodes in the document.</p></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>]</p><p>Transform<code>CDATASection</code>nodes in the document into<code>Text</code>nodes. The new<code>Text</code>node is then combined with any adjacent<code>Text</code>node.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-check-character-normalization"><code>"check-character-normalization"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>optional</emph>]</p><p>Check if the characters in the document are<loc href="http://www.w3.org/TR/2004/REC-xml11-20040204/#dt-fullnorm" type="simple" show="replace" actuate="onRequest">fully normalized</loc>, as defined in appendix B of<bibref ref="XML11"/>. When a sequence of characters is encountered that fails normalization checking, an error with the<code>DOMError.type</code>equals to "check-character-normalization-failure" is issued.</p></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Do not check if characters are normalized.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-comments"><code>"comments"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Keep<code>Comment</code>nodes in the document.</p></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>]</p><p>Discard<code>Comment</code>nodes in the document.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-datatype-normalization"><code>"datatype-normalization"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>optional</emph>]</p><p>Expose schema normalized values in the tree, such as<loc href="http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/#key-nv" type="simple" show="replace" actuate="onRequest">XML Schema normalized values</loc>in the case of XML Schema. Since this parameter requires to have<termref def="dt-schema">schema</termref>information, the "<termref def="parameter-validate">validate</termref>" parameter will also be set to<code>true</code>. Having this parameter activated when "validate" is<code>false</code>has no effect and no schema-normalization will happen.</p><note><p>Since the document contains the result of the XML 1.0 processing, this parameter does not apply to attribute value normalization as defined in section 3.3.3 of<bibref ref="XML"/>and is only meant for<termref def="dt-schema">schema</termref>languages other than Document Type Definition (DTD).</p></note></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Do not perform schema normalization on the tree.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-element-content-whitespace"><code>"element-content-whitespace"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Keep all whitespaces in the document.</p></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>optional</emph>]</p><p>Discard all<code>Text</code>nodes that contain whitespaces in element content, as described in<xspecref href="http://www.w3.org/TR/2004/REC-xml-infoset-20040204#infoitem.character" type="simple" show="new" actuate="onRequest">[element content whitespace]</xspecref>. The implementation is expected to use the attribute<code>Text.isElementContentWhitespace</code>to determine if a<code>Text</code>node should be discarded or not.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-entities"><code>"entities"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Keep<code>EntityReference</code>nodes in the document.</p></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>]</p><p>Remove all<code>EntityReference</code>nodes from the document, putting the entity expansions directly in their place.<code>Text</code>nodes are normalized, as defined in<code>Node.normalize</code>. Only<loc href="http://www.w3.org/TR/2004/REC-xml-infoset-20040204/#infoitem.rse" type="simple" show="replace" actuate="onRequest">unexpanded entity references</loc>are kept in the document.</p></def></gitem></glist><note><p>This parameter does not affect<code>Entity</code>nodes.</p></note></def></gitem><gitem><label id="parameter-error-handler"><code>"error-handler"</code></label><def><p>[<emph>required</emph>]</p><p>Contains a<code>DOMErrorHandler</code>object. If an error is encountered in the document, the implementation will call back the<code>DOMErrorHandler</code>registered using this parameter. The implementation may provide a default<code>DOMErrorHandler</code>object.</p><p>When called,<code>DOMError.relatedData</code>will contain the closest node to where the error occurred. If the implementation is unable to determine the node where the error occurs,<code>DOMError.relatedData</code>will contain the<code>Document</code>node. Mutations to the document from within an error handler will result in implementation dependent behavior.</p></def></gitem><gitem><label id="parameter-infoset"><code>"infoset"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>required</emph>]</p><p>Keep in the document the information defined in the XML Information Set<bibref ref="InfoSet"/>.</p><p>This forces the following parameters to<code>false</code>: "<termref def="parameter-validate-if-schema">validate-if-schema</termref>", "<termref def="parameter-entities">entities</termref>", "<termref def="parameter-datatype-normalization">datatype-normalization</termref>", "<termref def="parameter-cdata-sections">cdata-sections</termref>".</p><p>This forces the following parameters to<code>true</code>: "<termref def="parameter-namespace-declarations">namespace-declarations</termref>", "<termref def="parameter-well-formed">well-formed</termref>", "<termref def="parameter-element-content-whitespace">element-content-whitespace</termref>", "<termref def="parameter-comments">comments</termref>", "<termref def="parameter-namespaces">namespaces</termref>".</p><p>Other parameters are not changed unless explicitly specified in the description of the parameters.</p><p>Note that querying this parameter with<code>getParameter</code>returns<code>true</code>only if the individual parameters specified above are appropriately set.</p></def></gitem><gitem><label><code>false</code></label><def><p>Setting<code>infoset</code>to<code>false</code>has no effect.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-namespaces"><code>"namespaces"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Perform the namespace processing as defined in<specref ref="normalizeDocumentAlgo"/>.</p></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>optional</emph>]</p><p>Do not perform the namespace processing.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-namespace-declarations"><code>"namespace-declarations"</code></label><def><p>This parameter has no effect if the parameter "<termref def="parameter-namespaces">namespaces</termref>" is set to<code>false</code>.</p><glist><gitem><label><code>true</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Include namespace declaration attributes, specified or defaulted from the<termref def="dt-schema">schema</termref>, in the document. See also the sections "Declaring Namespaces" in<bibref ref="Namespaces"/>and<bibref ref="Namespaces11"/>.</p></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>]</p><p>Discard all namespace declaration attributes. The namespace prefixes (<code>Node.prefix</code>) are retained even if this parameter is set to<code>false</code>.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-normalize-characters"><code>"normalize-characters"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>optional</emph>]</p><p><loc href="http://www.w3.org/TR/2004/REC-xml11-20040204/#dt-fullnorm" type="simple" show="replace" actuate="onRequest">Fully normalized</loc>the characters in the document as defined in appendix B of<bibref ref="XML11"/>.</p></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Do not perform character normalization.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-schema-location"><code>"schema-location"</code></label><def><p>[<emph>optional</emph>]</p><p>Represent a<code>DOMString</code>object containing a list of URIs, separated by whitespaces (characters matching the<xspecref href="http://www.w3.org/TR/2004/REC-xml-20040204#NT-S" type="simple" show="new" actuate="onRequest">nonterminal production S</xspecref>defined in section 2.3<bibref ref="XML"/>), that represents the<termref def="dt-schema">schemas</termref>against which validation should occur, i.e. the current schema. The types of schemas referenced in this list must match the type specified with<code>schema-type</code>, otherwise the behavior of an implementation is undefined.</p><p>The schemas specified using this property take precedence to the schema information specified in the document itself. For namespace aware schema, if a schema specified using this property and a schema specified in the document instance (i.e. using the<code>schemaLocation</code>attribute) in a schema document (i.e. using schema<code>import</code>mechanisms) share the same<code>targetNamespace</code>, the schema specified by the user using this property will be used. If two schemas specified using this property share the same<code>targetNamespace</code>or have no namespace, the behavior is implementation dependent.</p><p>If no location has been provided, this parameter is<code>null</code>.</p><note><p>The<code>"schema-location"</code>parameter is ignored unless the "<termref def="parameter-schema-type">schema-type</termref>" parameter value is set. It is strongly recommended that<code>Document.documentURI</code>will be set so that an implementation can successfully resolve any external entities referenced.</p></note></def></gitem><gitem><label id="parameter-schema-type"><code>"schema-type"</code></label><def><p>[<emph>optional</emph>]</p><p>Represent a<code>DOMString</code>object containing an absolute URI and representing the type of the<termref def="dt-schema">schema</termref>language used to validate a document against. Note that no lexical checking is done on the absolute URI.</p><p>If this parameter is not set, a default value may be provided by the implementation, based on the schema languages supported and on the schema language used at load time. If no value is provided, this parameter is<code>null</code>.</p><note><p>For XML Schema<bibref ref="XMLSchema1"/>, applications must use the value<code>"http://www.w3.org/2001/XMLSchema"</code>. For XML DTD<bibref ref="XML"/>, applications must use the value<code>"http://www.w3.org/TR/REC-xml"</code>. Other schema languages are outside the scope of the W3C and therefore should recommend an absolute URI in order to use this method.</p></note></def></gitem><gitem><label id="parameter-split-cdata-sections"><code>"split-cdata-sections"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Split CDATA sections containing the CDATA section termination marker ']]>'. When a CDATA section is split a warning is issued with a<code>DOMError.type</code>equals to<code>"cdata-sections-splitted"</code>and<code>DOMError.relatedData</code>equals to the first<code>CDATASection</code>node in document order resulting from the split.</p></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>]</p><p>Signal an error if a<code>CDATASection</code>contains an unrepresentable character.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-validate"><code>"validate"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>optional</emph>]</p><p>Require the validation against a<termref def="dt-schema">schema</termref>(i.e. XML schema, DTD, any other type or representation of schema) of the document as it is being normalized as defined by<bibref ref="XML"/>. If validation errors are found, or no schema was found, the error handler is notified. Schema-normalized values will not be exposed according to the schema in used unless the parameter "<termref def="parameter-datatype-normalization">datatype-normalization</termref>" is<code>true</code>.</p><p>This parameter will reevaluate:</p><ulist><item><p>Attribute nodes with<code>Attr.specified</code>equals to<code>false</code>, as specified in the description of the<code>Attr</code>interface;</p></item><item><p>The value of the attribute<code>Text.isElementContentWhitespace</code>for all<code>Text</code>nodes;</p></item><item><p>The value of the attribute<code>Attr.isId</code>for all<code>Attr</code>nodes;</p></item><item><p>The attributes<code>Element.schemaTypeInfo</code>and<code>Attr.schemaTypeInfo</code>.</p></item></ulist><note><p>"<termref def="parameter-validate-if-schema">validate-if-schema</termref>" and "validate" are mutually exclusive, setting one of them to<code>true</code>will set the other one to<code>false</code>. Applications should also consider setting the parameter "<termref def="parameter-well-formed">well-formed</termref>" to<code>true</code>, which is the default for that option, when validating the document.</p></note></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Do not accomplish schema processing, including the internal subset processing. Default attribute values information are kept. Note that validation might still happen if "<termref def="parameter-validate-if-schema">validate-if-schema</termref>" is<code>true</code>.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-validate-if-schema"><code>"validate-if-schema"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>optional</emph>]</p><p>Enable validation only if a declaration for the document element can be found in a<termref def="dt-schema">schema</termref>(independently of where it is found, i.e. XML schema, DTD, or any other type or representation of schema). If validation is enabled, this parameter has the same behavior as the parameter "<termref def="parameter-validate">validate</termref>" set to<code>true</code>.</p><note><p>"validate-if-schema" and "<termref def="parameter-validate">validate</termref>" are mutually exclusive, setting one of them to<code>true</code>will set the other one to<code>false</code>.</p></note></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>No schema processing should be performed if the document has a schema, including internal subset processing. Default attribute values information are kept. Note that validation must still happen if "<termref def="parameter-validate">validate</termref>" is<code>true</code>.</p></def></gitem></glist></def></gitem><gitem><label id="parameter-well-formed"><code>"well-formed"</code></label><def><glist><gitem><label><code>true</code></label><def><p>[<emph>required</emph>] (<emph>default</emph>)</p><p>Check if all nodes are XML<termref def="dt-well-formed">well formed</termref>according to the XML version in use in<code>Document.xmlVersion</code>:</p><ulist><item><p>check if the attribute<code>Node.nodeName</code>contains invalid characters according to its node type and generate a<code>DOMError</code>of type<code>"wf-invalid-character-in-node-name"</code>, with a<code>DOMError.SEVERITY_ERROR</code>severity, if necessary;</p></item><item><p>check if the text content inside<code>Attr</code>,<code>Element</code>,<code>Comment</code>,<code>Text</code>,<code>CDATASection</code>nodes for invalid characters and generate a<code>DOMError</code>of type<code>"wf-invalid-character"</code>, with a<code>DOMError.SEVERITY_ERROR</code>severity, if necessary;</p></item><item><p>check if the data inside<code>ProcessingInstruction</code>nodes for invalid characters and generate a<code>DOMError</code>of type<code>"wf-invalid-character"</code>, with a<code>DOMError.SEVERITY_ERROR</code>severity, if necessary;</p></item></ulist></def></gitem><gitem><label><code>false</code></label><def><p>[<emph>optional</emph>]</p><p>Do not check for XML well-formedness.</p></def></gitem></glist></def></gitem></glist><p>The resolution of the system identifiers associated with entities is done using<code>Document.documentURI</code>. However, when the feature "LS" defined in<bibref role="informative" ref="DOMLS"/>is supported by the DOM implementation, the parameter "resource-resolver" can also be used on<code>DOMConfiguration</code>objects attached to<code>Document</code>nodes. If this parameter is set,<code>Document.normalizeDocument()</code>will invoke the resource resolver instead of using<code>Document.documentURI</code>.</p></descr><method name="setParameter" id="DOMConfiguration-property"><descr><p>Set the value of a parameter.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the parameter to set.</p></descr></param><param name="value" type="DOMUserData" attr="in"><descr><p>The new value or<code>null</code>if the user wishes to unset the parameter. While the type of the value parameter is defined as<code>DOMUserData</code>, the object type must match the type defined by the definition of the parameter. For example, if the parameter is<termref def="parameter-error-handler">"error-handler"</termref>, the value must be of type<code>DOMErrorHandler</code>.</p></descr></param></parameters><returns type="void"><descr></descr></returns><raises><exception name="DOMException"><descr><p>NOT_FOUND_ERR: Raised when the parameter name is not recognized.</p><p>NOT_SUPPORTED_ERR: Raised when the parameter name is recognized but the requested value cannot be set.</p><p>TYPE_MISMATCH_ERR: Raised if the value type for this parameter name is incompatible with the expected value type.</p></descr></exception></raises></method><method name="getParameter" id="DOMConfiguration-getParameter"><descr><p>Return the value of a parameter if known.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the parameter.</p></descr></param></parameters><returns type="DOMUserData"><descr><p>The current object associated with the specified parameter or<code>null</code>if no object has been associated or if the parameter is not supported.</p></descr></returns><raises><exception name="DOMException"><descr><p>NOT_FOUND_ERR: Raised when the parameter name is not recognized.</p></descr></exception></raises></method><method name="canSetParameter" id="DOMConfiguration-canSetParameter"><descr><p>Check if setting a parameter to a specific value is supported.</p></descr><parameters><param name="name" type="DOMString" attr="in"><descr><p>The name of the parameter to check.</p></descr></param><param name="value" type="DOMUserData" attr="in"><descr><p>An object. if<code>null</code>, the returned value is<code>true</code>.</p></descr></param></parameters><returns type="boolean"><descr><p><code>true</code>if the parameter could be successfully set to the specified value, or<code>false</code>if the parameter is not recognized or the requested value is not supported. This does not change the current value of the parameter itself.</p></descr></returns><raises></raises></method><attribute name="parameterNames" type="DOMStringList" readonly="yes" id="DOMConfiguration-parameterNames"><descr><p>The list of the parameters supported by this<code>DOMConfiguration</code>object and for which at least one value can be set by the application. Note that this list can also contain parameter names defined outside this specification.</p></descr></attribute></interface> |
| <interface name="CDATASection" inherits="Text" id="ID-667469212"><descr><p>CDATA sections are used to escape blocks of text containing characters that would otherwise be regarded as markup. The only delimiter that is recognized in a CDATA section is the "]]>" string that ends the CDATA section. CDATA sections cannot be nested. Their primary purpose is for including material such as XML fragments, without needing to escape all the delimiters.</p><p>The<code>CharacterData.data</code>attribute holds the text that is contained by the CDATA section. Note that this<emph>may</emph>contain characters that need to be escaped outside of CDATA sections and that, depending on the character encoding ("charset") chosen for serialization, it may be impossible to write out some characters as part of a CDATA section.</p><p>The<code>CDATASection</code>interface inherits from the<code>CharacterData</code>interface through the<code>Text</code>interface. Adjacent<code>CDATASection</code>nodes are not merged by use of the<code>normalize</code>method of the<code>Node</code>interface.</p><p>No lexical check is done on the content of a CDATA section and it is therefore possible to have the character sequence<code>"]]>"</code>in the content, which is illegal in a CDATA section per section 2.7 of<bibref ref="XML"/>. The presence of this character sequence must generate a fatal error during serialization or the cdata section must be splitted before the serialization (see also the parameter<code>"split-cdata-sections"</code>in the<code>DOMConfiguration</code>interface).</p><note><p>Because no markup is recognized within a<code>CDATASection</code>, character numeric references cannot be used as an escape mechanism when serializing. Therefore, action needs to be taken when serializing a<code>CDATASection</code>with a character encoding where some of the contained characters cannot be represented. Failure to do so would not produce well-formed XML.</p><p>One potential solution in the serialization process is to end the CDATA section before the character, output the character using a character reference or entity reference, and open a new CDATA section for any further characters in the text node. Note, however, that some code conversion libraries at the time of writing do not return an error or exception when a character is missing from the encoding, making the task of ensuring that data is not corrupted on serialization more difficult.</p></note></descr></interface> |
| <interface name="DocumentType" inherits="Node" id="ID-412266927"><descr><p>Each<code>Document</code>has a<code>doctype</code>attribute whose value is either<code>null</code>or a<code>DocumentType</code>object. The<code>DocumentType</code>interface in the DOM Core provides an interface to the list of entities that are defined for the document, and little else because the effect of namespaces and the various XML schema efforts on DTD representation are not clearly understood as of this writing.</p><p>DOM Level 3 doesn't support editing<code>DocumentType</code>nodes.<code>DocumentType</code>nodes are<termref def="dt-readonly-node">read-only</termref>.</p></descr><attribute readonly="yes" name="name" type="DOMString" id="ID-1844763134"><descr><p>The name of DTD; i.e., the name immediately following the<code>DOCTYPE</code>keyword.</p></descr></attribute><attribute readonly="yes" name="entities" type="NamedNodeMap" id="ID-1788794630"><descr><p>A<code>NamedNodeMap</code>containing the general entities, both external and internal, declared in the DTD. Parameter entities are not contained. Duplicates are discarded. For example in:<eg role="code" space="preserve"><!DOCTYPE ex SYSTEM "ex.dtd" [ <!ENTITY foo "foo"> <!ENTITY bar "bar"> <!ENTITY bar "bar2"> <!ENTITY % baz "baz"> ]> <ex/></eg>the interface provides access to<code>foo</code>and the first declaration of<code>bar</code>but not the second declaration of<code>bar</code>or<code>baz</code>. Every node in this map also implements the<code>Entity</code>interface.</p><p>The DOM Level 2 does not support editing entities, therefore<code>entities</code>cannot be altered in any way.</p></descr></attribute><attribute readonly="yes" name="notations" type="NamedNodeMap" id="ID-D46829EF"><descr><p>A<code>NamedNodeMap</code>containing the notations declared in the DTD. Duplicates are discarded. Every node in this map also implements the<code>Notation</code>interface.</p><p>The DOM Level 2 does not support editing notations, therefore<code>notations</code>cannot be altered in any way.</p></descr></attribute><attribute readonly="yes" name="publicId" type="DOMString" id="ID-Core-DocType-publicId" since="DOM Level 2"><descr><p>The public identifier of the external subset.</p></descr></attribute><attribute readonly="yes" name="systemId" type="DOMString" id="ID-Core-DocType-systemId" since="DOM Level 2"><descr><p>The system identifier of the external subset. This may be an absolute URI or not.</p></descr></attribute><attribute readonly="yes" name="internalSubset" type="DOMString" id="ID-Core-DocType-internalSubset" since="DOM Level 2"><descr><p>The internal subset as a string, or<code>null</code>if there is none. This is does not contain the delimiting square brackets.</p><note><p>The actual content returned depends on how much information is available to the implementation. This may vary depending on various parameters, including the XML processor used to build the document.</p></note></descr></attribute></interface> |
| <interface name="Notation" inherits="Node" id="ID-5431D1B9"><descr><p>This interface represents a notation declared in the DTD. A notation either declares, by name, the format of an unparsed entity (see<xspecref href="http://www.w3.org/TR/2004/REC-xml-20040204#Notations" type="simple" show="new" actuate="onRequest">section 4.7</xspecref>of the XML 1.0 specification<bibref ref="XML"/>), or is used for formal declaration of processing instruction targets (see<xspecref href="http://www.w3.org/TR/2004/REC-xml-20040204#sec-pi" type="simple" show="new" actuate="onRequest">section 2.6</xspecref>of the XML 1.0 specification<bibref ref="XML"/>). The<code>nodeName</code>attribute inherited from<code>Node</code>is set to the declared name of the notation.</p><p>The DOM Core does not support editing<code>Notation</code>nodes; they are therefore<termref def="dt-readonly-node">readonly</termref>.</p><p>A<code>Notation</code>node does not have any parent.</p></descr><attribute readonly="yes" name="publicId" type="DOMString" id="ID-54F2B4D0"><descr><p>The public identifier of this notation. If the public identifier was not specified, this is<code>null</code>.</p></descr></attribute><attribute readonly="yes" name="systemId" type="DOMString" id="ID-E8AAB1D0"><descr><p>The system identifier of this notation. If the system identifier was not specified, this is<code>null</code>. This may be an absolute URI or not.</p></descr></attribute></interface> |
| <interface name="Entity" inherits="Node" id="ID-527DCFF2"><descr><p>This interface represents a known entity, either parsed or unparsed, in an XML document. Note that this models the entity itself<emph>not</emph>the entity declaration.</p><p>The<code>nodeName</code>attribute that is inherited from<code>Node</code>contains the name of the entity.</p><p>An XML processor may choose to completely expand entities before the structure model is passed to the DOM; in this case there will be no<code>EntityReference</code>nodes in the document tree.</p><p>XML does not mandate that a non-validating XML processor read and process entity declarations made in the external subset or declared in parameter entities. This means that parsed entities declared in the external subset need not be expanded by some classes of applications, and that the replacement text of the entity may not be available. When the<xspecref href="http://www.w3.org/TR/2004/REC-xml-20040204#intern-replacement" type="simple" show="new" actuate="onRequest">replacement text</xspecref>is available, the corresponding<code>Entity</code>node's child list represents the structure of that replacement value. Otherwise, the child list is empty.</p><p>DOM Level 3 does not support editing<code>Entity</code>nodes; if a user wants to make changes to the contents of an<code>Entity</code>, every related<code>EntityReference</code>node has to be replaced in the structure model by a clone of the<code>Entity</code>'s contents, and then the desired changes must be made to each of those clones instead.<code>Entity</code>nodes and all their<termref def="dt-descendant">descendants</termref>are<termref def="dt-readonly-node">readonly</termref>.</p><p>An<code>Entity</code>node does not have any parent.</p><note><p>If the entity contains an unbound<termref def="dt-namespaceprefix">namespace prefix</termref>, the<code>namespaceURI</code>of the corresponding node in the<code>Entity</code>node subtree is<code>null</code>. The same is true for<code>EntityReference</code>nodes that refer to this entity, when they are created using the<code>createEntityReference</code>method of the<code>Document</code>interface.</p></note></descr><attribute readonly="yes" name="publicId" type="DOMString" id="ID-D7303025"><descr><p>The public identifier associated with the entity if specified, and<code>null</code>otherwise.</p></descr></attribute><attribute readonly="yes" name="systemId" type="DOMString" id="ID-D7C29F3E"><descr><p>The system identifier associated with the entity if specified, and<code>null</code>otherwise. This may be an absolute URI or not.</p></descr></attribute><attribute readonly="yes" name="notationName" type="DOMString" id="ID-6ABAEB38"><descr><p>For unparsed entities, the name of the notation for the entity. For parsed entities, this is<code>null</code>.</p></descr></attribute><attribute readonly="yes" type="DOMString" name="inputEncoding" id="Entity3-inputEncoding" since="DOM Level 3"><descr><p>An attribute specifying the encoding used for this entity at the time of parsing, when it is an external parsed entity. This is<code>null</code>if it an entity from the internal subset or if it is not known.</p></descr></attribute><attribute readonly="yes" type="DOMString" name="xmlEncoding" id="Entity3-encoding" since="DOM Level 3"><descr><p>An attribute specifying, as part of the text declaration, the encoding of this entity, when it is an external parsed entity. This is<code>null</code>otherwise.</p></descr></attribute><attribute readonly="yes" type="DOMString" name="xmlVersion" id="Entity3-version" since="DOM Level 3"><descr><p>An attribute specifying, as part of the text declaration, the version number of this entity, when it is an external parsed entity. This is<code>null</code>otherwise.</p></descr></attribute></interface> |
| <interface name="EntityReference" inherits="Node" id="ID-11C98490"><descr><p><code>EntityReference</code>nodes may be used to represent an entity reference in the tree. Note that character references and references to predefined entities are considered to be expanded by the HTML or XML processor so that characters are represented by their Unicode equivalent rather than by an entity reference. Moreover, the XML processor may completely expand references to entities while building the<code>Document</code>, instead of providing<code>EntityReference</code>nodes. If it does provide such nodes, then for an<code>EntityReference</code>node that represents a reference to a known entity an<code>Entity</code>exists, and the subtree of the<code>EntityReference</code>node is a copy of the<code>Entity</code>node subtree. However, the latter may not be true when an entity contains an unbound<termref def="dt-namespaceprefix">namespace prefix</termref>. In such a case, because the namespace prefix resolution depends on where the entity reference is, the<termref def="dt-descendant">descendants</termref>of the<code>EntityReference</code>node may be bound to different<termref def="dt-namespaceURI">namespace URIs</termref>. When an<code>EntityReference</code>node represents a reference to an unknown entity, the node has no children and its replacement value, when used by<code>Attr.value</code>for example, is empty.</p><p>As for<code>Entity</code>nodes,<code>EntityReference</code>nodes and all their<termref def="dt-descendant">descendants</termref>are<termref def="dt-readonly-node">readonly</termref>.</p><note><p><code>EntityReference</code>nodes may cause element content and attribute value normalization problems when, such as in XML 1.0 and XML Schema, the normalization is performed after entity reference are expanded.</p></note></descr></interface> |
| <interface name="ProcessingInstruction" inherits="Node" id="ID-1004215813"><descr><p>The<code>ProcessingInstruction</code>interface represents a "processing instruction", used in XML as a way to keep processor-specific information in the text of the document.</p><p>No lexical check is done on the content of a processing instruction and it is therefore possible to have the character sequence<code>"?>"</code>in the content, which is illegal a processing instruction per section 2.6 of<bibref ref="XML"/>. The presence of this character sequence must generate a fatal error during serialization.</p></descr><attribute readonly="yes" type="DOMString" name="target" id="ID-1478689192"><descr><p>The target of this processing instruction. XML defines this as being the first<termref def="dt-token">token</termref>following the markup that begins the processing instruction.</p></descr></attribute><attribute type="DOMString" name="data" id="ID-837822393" readonly="no"><descr><p>The content of this processing instruction. This is from the first non white space character after the target to the character immediately preceding the<code>?></code>.</p></descr><setraises><exception name="DOMException"><descr><p>NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.</p></descr></exception></setraises></attribute></interface> |
| <interface id="i18n-methods-StringExtend" name="StringExtend"><descr><p>Extensions to a language's native String class or interface</p></descr><method id="i18n-methods-StringExtend-findOffset16" name="findOffset16"><descr><p>Returns the UTF-16 offset that corresponds to a UTF-32 offset. Used for random access.</p><note><p>You can always round-trip from a UTF-32 offset to a UTF-16 offset and back. You can round-trip from a UTF-16 offset to a UTF-32 offset and back if and only if the offset16 is not in the middle of a surrogate pair. Unmatched surrogates count as a single UTF-16 value.</p></note></descr><parameters><param name="offset32" type="int" attr="in"><descr><p>UTF-32 offset.</p></descr></param></parameters><returns type="int"><descr><p>UTF-16 offset</p></descr></returns><raises><exception name="StringIndexOutOfBoundsException"><descr><p>if<code>offset32</code>is out of bounds.</p></descr></exception></raises></method><method id="i18n-methods-StringExtend-findOffset32" name="findOffset32"><descr><p>Returns the UTF-32 offset corresponding to a UTF-16 offset. Used for random access. To find the UTF-32 length of a string, use:<eg space="preserve">len32 = findOffset32(source, source.length());</eg></p><note><p>If the UTF-16 offset is into the middle of a surrogate pair, then the UTF-32 offset of the<emph>end</emph>of the pair is returned; that is, the index of the char after the end of the pair. You can always round-trip from a UTF-32 offset to a UTF-16 offset and back. You can round-trip from a UTF-16 offset to a UTF-32 offset and back if and only if the offset16 is not in the middle of a surrogate pair. Unmatched surrogates count as a single UTF-16 value.</p></note></descr><parameters><param attr="in" type="int" name="offset16"><descr><p>UTF-16 offset</p></descr></param></parameters><returns type="int"><descr><p>UTF-32 offset</p></descr></returns><raises><exception name="StringIndexOutOfBoundsException"><descr><p>if offset16 is out of bounds.</p></descr></exception></raises></method></interface> |
| </library> |
| /contrib/network/netsurf/libdom/test/dom3-events-interface.xml |
|---|
| 0,0 → 1,1472 |
| <?xml version="1.0"?> |
| <!-- |
| Copyright (c) 2002-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Document |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!--This file is an extract of interface definitions from Document Object Model (DOM) Level 3 Events Specification--> |
| <library xmlns:xlink="http://www.w3.org/1999/xlink"> |
| <interface name="Event" id="Events-Event" since="DOM Level 2"> |
| <descr> |
| <p>The<code>Event</code>interface is used to provide contextual information about an event to the listener processing the event. An object which implements the<code>Event</code>interface is passed as the parameter to an<code>EventListener</code>. More specific context information is passed to event listeners by deriving additional interfaces from<code>Event</code>which contain information directly relating to the type of event they represent. These derived interfaces are also implemented by the object passed to the event listener.</p> |
| <p>To create an instance of the<code>Event</code>interface, use the<code>DocumentEvent.createEvent("Event")</code>method call.</p> |
| </descr> |
| <group id="Events-Event-eventPhaseType" name="PhaseType"> |
| <descr> |
| <p>An integer indicating which phase of the event flow is being processed as defined in<specref ref="Events-flow"/>.</p> |
| </descr> |
| <constant name="CAPTURING_PHASE" id="CAPTURING_PHASE" type="unsigned short" value="1"> |
| <descr> |
| <p>The current event phase is the<termref def="dt-capture-phase">capture phase</termref>.</p> |
| </descr> |
| </constant> |
| <constant name="AT_TARGET" id="AT_TARGET" type="unsigned short" value="2"> |
| <descr> |
| <p>The current event is in the<termref def="dt-capture-phase">target phase</termref>, i.e. it is being evaluated at the<termref def="dt-event-target">event target</termref>.</p> |
| </descr> |
| </constant> |
| <constant name="BUBBLING_PHASE" id="BUBBLING_PHASE" type="unsigned short" value="3"> |
| <descr> |
| <p>The current event phase is the<termref def="dt-bubbling-phase">bubbling phase</termref>.</p> |
| </descr> |
| </constant> |
| </group> |
| <attribute type="DOMString" name="type" readonly="yes" id="Events-Event-type"> |
| <descr> |
| <p>The name should be anas defined in<bibref ref="Namespaces"/>and is case-sensitive.</p> |
| <p>If the attribute<code>Event.namespaceURI</code>is different from<code>null</code>, this attribute represents a<termref def="dt-localname">local name</termref>.</p> |
| </descr> |
| </attribute> |
| <attribute type="EventTarget" name="target" readonly="yes" id="Events-Event-target"> |
| <descr> |
| <p>Used to indicate the<termref def="dt-event-target">event target</termref>. This attribute contains the<termref def="dt-target-node">target node</termref>when used with the<specref ref="Events-flow"/>.</p> |
| </descr> |
| </attribute> |
| <attribute type="EventTarget" name="currentTarget" readonly="yes" id="Events-Event-currentTarget"> |
| <descr> |
| <p>Used to indicate the<code>EventTarget</code>whose<code>EventListeners</code>are currently being processed. This is particularly useful during the capture and bubbling phases. This attribute could contain the<termref def="dt-target-node">target node</termref>or a target ancestor when used with the<specref ref="Events-flow"/>.</p> |
| </descr> |
| </attribute> |
| <attribute type="unsigned short" name="eventPhase" readonly="yes" id="Events-Event-eventPhase"> |
| <descr> |
| <p>Used to indicate which phase of event flow is currently being accomplished.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="bubbles" readonly="yes" id="Events-Event-canBubble"> |
| <descr> |
| <p>Used to indicate whether or not an event is a bubbling event. If the event can bubble the value is<code>true</code>, otherwise the value is<code>false</code>.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="cancelable" readonly="yes" id="Events-Event-canCancel"> |
| <descr> |
| <p>Used to indicate whether or not an event can have its default action prevented (see also<specref ref="Events-flow-cancelation"/>). If the default action can be prevented the value is<code>true</code>, otherwise the value is<code>false</code>.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMTimeStamp" name="timeStamp" readonly="yes" id="Events-Event-timeStamp"> |
| <descr> |
| <p>Used to specify the time (in milliseconds relative to the epoch) at which the event was created. Due to the fact that some systems may not provide this information the value of<code>timeStamp</code>may be not available for all events. When not available, a value of<code>0</code>will be returned. Examples of epoch time are the time of the system start or 0:0:0 UTC 1st January 1970.</p> |
| </descr> |
| </attribute> |
| <method name="stopPropagation" id="Events-Event-stopPropagation"> |
| <descr> |
| <p>This method is used to prevent event listeners of the same group to be triggered but its effect is deferred until all event listeners attached on the<code>currentTarget</code>have been triggered (see<specref ref="Events-propagation-and-groups"/>). Once it has been called, further calls to that method have no additional effect.</p> |
| <note> |
| <p>This method does not prevent the default action from being invoked; use<code>preventDefault</code>for that effect.</p> |
| </note> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="preventDefault" id="Events-Event-preventDefault"> |
| <descr> |
| <p>If an event is cancelable, the<code>preventDefault</code>method is used to signify that the event is to be canceled, meaning any default action normally taken by the implementation as a result of the event will not occur (see also<specref ref="Events-flow-cancelation"/>), and thus independently of event groups. Calling this method for a non-cancelable event has no effect.</p> |
| <note> |
| <p>This method does not stop the event propagation; use<code>stopPropagation</code>or<code>stopImmediatePropagation</code>for that effect.</p> |
| </note> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="initEvent" id="Events-Event-initEvent"> |
| <descr> |
| <p>The<code>initEvent</code>method is used to initialize the value of an<code>Event</code>created through the<code>DocumentEvent.createEvent</code>method. This method may only be called before the<code>Event</code>has been dispatched via the<code>EventTarget.dispatchEvent()</code>method. If the method is called several times before invoking<code>EventTarget.dispatchEvent</code>, only the final invocation takes precedence. This method has no effect if called after the event has been dispatched. If called from a subclass of the<code>Event</code>interface only the values specified in this method are modified, all other attributes are left unchanged.</p> |
| <p>This method sets the<code>Event.type</code>attribute to<code>eventTypeArg</code>, and<code>Event.namespaceURI</code>to<code>null</code>. To initialize an event with a namespace URI, use the<code>Event.initEventNS(namespaceURIArg, eventTypeArg, ...)</code>method.</p> |
| </descr> |
| <parameters> |
| <param name="eventTypeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies<code>Event.type</code>.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies<code>Event.bubbles</code>. This parameter overrides the intrinsic bubbling behavior of the event.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies<code>Event.cancelable</code>. This parameter overrides the intrinsic cancelable behavior of the event.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <attribute readonly="yes" type="DOMString" name="namespaceURI" id="Events-Event-namespaceURI" since="DOM Level 3"> |
| <descr> |
| <p>The<termref def="dt-namespaceURI">namespace URI</termref>associated with this event at creation time, or<code>null</code>if it is unspecified.</p> |
| <p>For events initialized with a DOM Level 2 Events method, such as<code>Event.initEvent()</code>, this is always<code>null</code>.</p> |
| </descr> |
| </attribute> |
| <method name="isCustom" id="Events-Event-isCustom" since="DOM Level 3"> |
| <descr> |
| <p>This method will always return<code>false</code>, unless the event implements the<code>CustomEvent</code>interface.</p> |
| </descr> |
| <parameters/> |
| <returns type="boolean"> |
| <descr> |
| <p><code>false</code>, unless the event object implements the<code>CustomEvent</code>interface.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="stopImmediatePropagation" id="Events-Event-stopImmediatePropagation" since="DOM Level 3"> |
| <descr> |
| <p>This method is used to prevent event listeners of the same group to be triggered and, unlike<code>stopPropagation</code>its effect is immediate (see<specref ref="Events-propagation-and-groups"/>). Once it has been called, further calls to that method have no additional effect.</p> |
| <note> |
| <p>This method does not prevent the default action from being invoked; use<code>Event.preventDefault()</code>for that effect.</p> |
| </note> |
| </descr> |
| <parameters/> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="isDefaultPrevented" id="Events-Event-isDefaultPrevented" since="DOM Level 3"> |
| <descr> |
| <p>This method will return<code>true</code>if the method<code>Event.preventDefault()</code>has been called for this event,<code>false</code>otherwise.</p> |
| </descr> |
| <parameters/> |
| <returns type="boolean"> |
| <descr> |
| <p><code>true</code>if<code>Event.preventDefault()</code>has been called for this event.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="initEventNS" id="Events-Event-initEventNS" since="DOM Level 3"> |
| <descr> |
| <p>The<code>initEventNS</code>method is used to initialize the value of an<code>Event</code>object and has the same behavior as<code>Event.initEvent()</code>.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURIArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies<code>Event.namespaceuRI</code>, the<termref def="dt-namespaceURI">namespace URI</termref>associated with this event, or<code>null</code>if no namespace.</p> |
| </descr> |
| </param> |
| <param name="eventTypeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies<code>Event.type</code>, the<termref def="dt-localname">local name</termref>of the event type.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="EventTarget" id="Events-EventTarget" since="DOM Level 2"> |
| <descr> |
| <p>The<code>EventTarget</code>interface is implemented by all the objects which could be<termref def="dt-event-target">event targets</termref>in an implementation which supports the<specref ref="Events-flows"/>. The interface allows registration, removal or query of event listeners, and dispatch of events to an event target.</p> |
| <p>When used with<specref ref="Events-flow"/>, this interface is implemented by all<termref def="dt-target-node">target nodes</termref>and target ancestors, i.e. all DOM<code>Nodes</code>of the tree support this interface when the implementation conforms to DOM Level 3 Events and, therefore, this interface can be obtained by using binding-specific casting methods on an instance of the<code>Node</code>interface.</p> |
| <p>Invoking<code>addEventListener</code>or<code>addEventListenerNS</code>multiple times on the same<code>EventTarget</code>with the same parameters (<code>namespaceURI</code>,<code>type</code>,<code>listener</code>, and<code>useCapture</code>) is considered to be a no-op and thus independently of the event group. They do not cause the<code>EventListener</code>to be called more than once and do not cause a change in the triggering order. In order to guarantee that an event listener will be added to the event target for the specified event group, one needs to invoke<code>removeEventListener</code>or<code>removeEventListenerNS</code>first.</p> |
| </descr> |
| <method name="addEventListener" id="Events-EventTarget-addEventListener"> |
| <descr> |
| <p>This method allows the registration of an event listener in the default group and, depending on the<code>useCapture</code>parameter, on the capture phase of the DOM event flow or its target and bubbling phases.</p> |
| </descr> |
| <parameters> |
| <param name="type" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.type</code>associated with the event for which the user is registering.</p> |
| </descr> |
| </param> |
| <param name="listener" type="EventListener" attr="in"> |
| <descr> |
| <p>The<code>listener</code>parameter takes an object implemented by the user which implements the<code>EventListener</code>interface and contains the method to be called when the event occurs.</p> |
| </descr> |
| </param> |
| <param name="useCapture" type="boolean" attr="in"> |
| <descr> |
| <p>If true,<code>useCapture</code>indicates that the user wishes to add the event listener for the<termref def="dt-capture-phase">capture phase</termref>only, i.e. this event listener will not be triggered during the<termref def="dt-target-phase">target</termref>and<termref def="dt-bubbling-phase">bubbling</termref>phases. If<code>false</code>, the event listener will only be triggered during the target and bubbling phases.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="removeEventListener" id="Events-EventTarget-removeEventListener"> |
| <descr> |
| <p>This method allows the removal of event listeners from the default group.</p> |
| <p>Calling<code>removeEventListener</code>with arguments which do not identify any currently registered<code>EventListener</code>on the<code>EventTarget</code>has no effect.</p> |
| </descr> |
| <parameters> |
| <param name="type" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.type</code>for which the user registered the event listener.</p> |
| </descr> |
| </param> |
| <param name="listener" type="EventListener" attr="in"> |
| <descr> |
| <p>The<code>EventListener</code>to be removed.</p> |
| </descr> |
| </param> |
| <param name="useCapture" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether the<code>EventListener</code>being removed was registered for the capture phase or not. If a listener was registered twice, once for the capture phase and once for the target and bubbling phases, each must be removed separately. Removal of an event listener registered for the capture phase does not affect the same event listener registered for the target and bubbling phases, and vice versa.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="dispatchEvent" id="Events-EventTarget-dispatchEvent" version="DOM Level 3"> |
| <descr> |
| <p>This method allows the dispatch of events into the implementation's event model. The<termref def="dt-event-target">event target</termref>of the event is the<code>EventTarget</code>object on which<code>dispatchEvent</code>is called.</p> |
| </descr> |
| <parameters> |
| <param name="evt" type="Event" attr="in"> |
| <descr> |
| <p>The event to be dispatched.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="boolean"> |
| <descr> |
| <p>Indicates whether any of the listeners which handled the event called<code>Event.preventDefault()</code>. If<code>Event.preventDefault()</code>was called the returned value is<code>false</code>, else it is<code>true</code>.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="EventException"> |
| <descr> |
| <p>UNSPECIFIED_EVENT_TYPE_ERR: Raised if the<code>Event.type</code>was not specified by initializing the event before<code>dispatchEvent</code>was called. Specification of the<code>Event.type</code>as<code>null</code>or an empty string will also trigger this exception.</p> |
| <p>DISPATCH_REQUEST_ERR: Raised if the<code>Event</code>object is already being dispatched in the tree.</p> |
| <p>NOT_SUPPORTED_ERR: Raised if the<code>Event</code>object has not been created using<code>DocumentEvent.createEvent()</code>or does not support the interface<code>CustomEvent</code>.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="addEventListenerNS" id="Events-EventTargetGroup-addEventListenerNS" since="DOM Level 3"> |
| <descr> |
| <p>This method allows the registration of an event listener in a specified group or the default group and, depending on the<code>useCapture</code>parameter, on the capture phase of the DOM event flow or its target and bubbling phases.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.namespaceURI</code>associated with the event for which the user is registering.</p> |
| </descr> |
| </param> |
| <param name="type" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.type</code>associated with the event for which the user is registering.</p> |
| </descr> |
| </param> |
| <param name="listener" type="EventListener" attr="in"> |
| <descr> |
| <p>The<code>listener</code>parameter takes an object implemented by the user which implements the<code>EventListener</code>interface and contains the method to be called when the event occurs.</p> |
| </descr> |
| </param> |
| <param name="useCapture" type="boolean" attr="in"> |
| <descr> |
| <p>If true,<code>useCapture</code>indicates that the user wishes to add the event listener for the<termref def="dt-capture-phase">capture phase</termref>only, i.e. this event listener will not be triggered during the<termref def="dt-target-phase">target</termref>and<termref def="dt-bubbling-phase">bubbling</termref>phases. If<code>false</code>, the event listener will only be triggered during the target and bubbling phases.</p> |
| </descr> |
| </param> |
| <param name="evtGroup" type="DOMObject" attr="in"> |
| <descr> |
| <p>The object that represents the event group to associate with the<code>EventListener</code>(see also<specref ref="Events-propagation-and-groups"/>). Use<code>null</code>to attach the event listener to the default group.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr/> |
| </returns> |
| <raises/> |
| </method> |
| <method name="removeEventListenerNS" id="Events-EventTargetGroup-removeEventListenerNS" since="DOM Level 3"> |
| <descr> |
| <p>This method allows the removal of an event listener, independently of the associated event group.</p> |
| <p>Calling<code>removeEventListenerNS</code>with arguments which do not identify any currently registered<code>EventListener</code>on the<code>EventTarget</code>has no effect.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.namespaceURI</code>associated with the event for which the user registered the event listener.</p> |
| </descr> |
| </param> |
| <param name="type" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.type</code>associated with the event for which the user registered the event listener.</p> |
| </descr> |
| </param> |
| <param name="listener" type="EventListener" attr="in"> |
| <descr> |
| <p>The<code>EventListener</code>parameter indicates the<code>EventListener</code>to be removed.</p> |
| </descr> |
| </param> |
| <param name="useCapture" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies whether the<code>EventListener</code>being removed was registered for the capture phase or not. If a listener was registered twice, once for the capture phase and once for the target and bubbling phases, each must be removed separately. Removal of an event listener registered for the capture phase does not affect the same event listener registered for the target and bubbling phases, and vice versa.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="willTriggerNS" since="DOM Level 3" id="Events3-willTriggerNS"> |
| <descr> |
| <p>This method allows the DOM application to know if an event listener, attached to this<code>EventTarget</code>or one of its ancestors, will be triggered by the specified event type during the dispatch of the event to this event target or one of its descendants.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.namespaceURI</code>associated with the event.</p> |
| </descr> |
| </param> |
| <param name="type" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.type</code>associated with the event.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="boolean"> |
| <descr> |
| <p><code>true</code>if an event listener will be triggered on the<code>EventTarget</code>with the specified event type,<code>false</code>otherwise.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="hasEventListenerNS" since="DOM Level 3" id="Events3-hasEventListenerNS"> |
| <descr> |
| <p>This method allows the DOM application to know if this<code>EventTarget</code>contains an event listener registered for the specified event type. This is useful for determining at which nodes within a hierarchy altered handling of specific event types has been introduced, but should not be used to determine whether the specified event type triggers an event listener (see<code>EventTarget.willTriggerNS()</code>).</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.namespaceURI</code>associated with the event.</p> |
| </descr> |
| </param> |
| <param name="type" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.type</code>associated with the event.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="boolean"> |
| <descr> |
| <p><code>true</code>if an event listener is registered on this<code>EventTarget</code>for the specified event type,<code>false</code>otherwise.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface id="Events-EventListener" name="EventListener" since="DOM Level 2" role="ecmascript-function"> |
| <descr> |
| <p>The<code>EventListener</code>interface is the primary way for handling events. Users implement the<code>EventListener</code>interface and register their event listener on an<code>EventTarget</code>. The users should also remove their<code>EventListener</code>from its<code>EventTarget</code>after they have completed using the listener.</p> |
| <p>Copying a<code>Node</code>, with methods such as<code>Node.cloneNode</code>or<code>Range.cloneContents</code>, does not copy the event listeners attached to it. Event listeners must be attached to the newly created<code>Node</code>afterwards if so desired.</p> |
| <p>Moving a<code>Node</code>, with methods<code>Document.adoptNode</code>,<code>Node.appendChild</code>, or<code>Range.extractContents</code>, does not affect the event listeners attached to it.</p> |
| </descr> |
| <method name="handleEvent" id="Events-EventListener-handleEvent"> |
| <descr> |
| <p>This method is called whenever an event occurs of the event type for which the<code>EventListener</code>interface was registered.</p> |
| </descr> |
| <parameters> |
| <param name="evt" type="Event" attr="in"> |
| <descr> |
| <p>The<code>Event</code>contains contextual information about the<termref def="dt-event">event</termref>.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <exception id="Events-EventException" name="EventException" since="DOM Level 2"> |
| <descr> |
| <p>Event operations may throw an<code>EventException</code>as specified in their method descriptions.</p> |
| </descr> |
| <component id="Events-EventException-code" name="code"> |
| <typename>unsigned short</typename> |
| </component> |
| </exception> |
| <group id="Events-EventException-EventExceptionCode" name="EventExceptionCode" since="DOM Level 2"> |
| <descr> |
| <p>An integer indicating the type of error generated.</p> |
| </descr> |
| <constant name="UNSPECIFIED_EVENT_TYPE_ERR" id="UNSPECIFIED_EVENT_TYPE_ERR" type="unsigned short" value="0"> |
| <descr> |
| <p>If the<code>Event.type</code>was not specified by initializing the event before the method was called. Specification of the<code>Event.type</code>as<code>null</code>or an empty string will also trigger this exception.</p> |
| </descr> |
| </constant> |
| <constant name="DISPATCH_REQUEST_ERR" id="DISPATCH_REQUEST_ERR" type="unsigned short" value="1" since="DOM Level 3"> |
| <descr> |
| <p>If the<code>Event</code>object is already dispatched in the tree.</p> |
| </descr> |
| </constant> |
| </group> |
| <interface name="DocumentEvent" id="Events-DocumentEvent" since="DOM Level 2"> |
| <descr> |
| <p>The<code>DocumentEvent</code>interface provides a mechanism by which the user can create an<code>Event</code>object of a type supported by the implementation. If the feature "Events" is supported by the<code>Document</code>object, the<code>DocumentEvent</code>interface must be implemented on the same object. If the feature "+Events" is supported by the<code>Document</code>object, an object that supports the<code>DocumentEvent</code>interface must be returned by invoking the method<code>Node.getFeature("+Events", "3.0")</code>on the<code>Document</code>object.</p> |
| </descr> |
| <method name="createEvent" id="Events-DocumentEvent-createEvent"> |
| <descr> |
| <p/> |
| </descr> |
| <parameters> |
| <param name="eventType" type="DOMString" attr="in"> |
| <descr> |
| <p>The<code>eventType</code>parameter specifies the name of the DOM Events interface to be supported by the created event object, e.g.<code>"Event"</code>,<code>"MouseEvent"</code>,<code>"MutationEvent"</code>and so on. If the<code>Event</code>is to be dispatched via the<code>EventTarget.dispatchEvent()</code>method the appropriate event init method must be called after creation in order to initialize the<code>Event</code>'s values.</p> |
| <p>As an example, a user wishing to synthesize some kind of<code>UIEvent</code>would invoke<code>DocumentEvent.createEvent("UIEvent")</code>. The<code>UIEvent.initUIEventNS()</code>method could then be called on the newly created<code>UIEvent</code>object to set the specific type of user interface event to be dispatched,<code>{"http://www.w3.org/2001/xml-events", "DOMActivate"}</code>for example, and set its context information, e.g.<code>UIEvent.detail</code>in this example.</p> |
| <p>The<code>createEvent</code>method is used in creating<code>Event</code>s when it is either inconvenient or unnecessary for the user to create an<code>Event</code>themselves. In cases where the implementation provided<code>Event</code>is insufficient, users may supply their own<code>Event</code>implementations for use with the<code>EventTarget.dispatchEvent()</code>method. However, the DOM implementation needs access to the attributes<code>Event.currentTarget</code>and<code>Event.eventPhase</code>to appropriately propagate the event in the DOM tree. Therefore users'<code>Event</code>implementations might need to support the<code>CustomEvent</code>interface for that effect.</p> |
| <note> |
| <p>For backward compatibility reason, "UIEvents", "MouseEvents", "MutationEvents", and "HTMLEvents" feature names are valid values for the parameter<code>eventType</code>and represent respectively the interfaces "UIEvent", "MouseEvent", "MutationEvent", and "Event".</p> |
| </note> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="Event"> |
| <descr> |
| <p>The newly created event object.</p> |
| </descr> |
| </returns> |
| <raises> |
| <exception name="DOMException"> |
| <descr> |
| <p>NOT_SUPPORTED_ERR: Raised if the implementation does not support the<code>Event</code>interface requested.</p> |
| </descr> |
| </exception> |
| </raises> |
| </method> |
| <method name="canDispatch" id="Events-DocumentEvent-canDispatch" since="DOM Level 3"> |
| <descr> |
| <p>Test if the implementation can generate events of a specified type.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.namespaceURI</code>of the event.</p> |
| </descr> |
| </param> |
| <param name="type" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies the<code>Event.type</code>of the event.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="boolean"> |
| <descr> |
| <p><code>true</code>if the implementation can generate and dispatch this event type,<code>false</code>otherwise.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="CustomEvent" inherits="Event" id="Events-CustomEvent" since="DOM Level 3"> |
| <descr> |
| <p>The<code>CustomEvent</code>interface gives access to the attributes<code>Event.currentTarget</code>and<code>Event.eventPhase</code>. It is intended to be used by the DOM Events implementation to access the underlying current target and event phase while dispatching a custom<code>Event</code>in the tree; it is also intended to be implemented, and<emph>not used</emph>, by DOM applications.</p> |
| <p>The methods contained in this interface are not intended to be used by a DOM application, especially during the dispatch on the<code>Event</code>object. Changing the current target or the current phase may result in unpredictable results of the event flow. The DOM Events implementation should ensure that both methods return the appropriate current target and phase before invoking each event listener on the current target to protect DOM applications from malicious event listeners.</p> |
| <note> |
| <p>If this interface is supported by the event object,<code>Event.isCustom()</code>must return<code>true</code>.</p> |
| </note> |
| </descr> |
| <method name="setDispatchState" id="Events-CustomEvent-setCurrentTarget"> |
| <descr> |
| <p>The<code>setDispatchState</code>method is used by the DOM Events implementation to set the values of<code>Event.currentTarget</code>and<code>Event.eventPhase</code>. It also reset the states of<code>isPropagationStopped</code>and<code>isImmediatePropagationStopped</code>.</p> |
| </descr> |
| <parameters> |
| <param name="target" type="EventTarget" attr="in"> |
| <descr> |
| <p>Specifies the new value for the<code>Event.currentTarget</code>attribute.</p> |
| </descr> |
| </param> |
| <param name="phase" type="unsigned short" attr="in"> |
| <descr> |
| <p>Specifies the new value for the<code>Event.eventPhase</code>attribute.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr/> |
| </returns> |
| <raises/> |
| </method> |
| <method name="isPropagationStopped" id="Events-Event-isPropagationStopped"> |
| <descr> |
| <p>This method will return<code>true</code>if the method<code>stopPropagation()</code>has been called for this event,<code>false</code>in any other cases.</p> |
| </descr> |
| <parameters/> |
| <returns type="boolean"> |
| <descr> |
| <p><code>true</code>if the event propagation has been stopped in the current group.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="isImmediatePropagationStopped" id="Events-Event-isImmediatePropagationStopped"> |
| <descr> |
| <p>The<code>isImmediatePropagationStopped</code>method is used by the DOM Events implementation to know if the method<code>stopImmediatePropagation()</code>has been called for this event. It returns<code>true</code>if the method has been called,<code>false</code>otherwise.</p> |
| </descr> |
| <parameters/> |
| <returns type="boolean"> |
| <descr> |
| <p><code>true</code>if the event propagation has been stopped immediately in the current group.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="UIEvent" inherits="Event" id="Events-UIEvent" since="DOM Level 2"> |
| <descr> |
| <p>The<code>UIEvent</code>interface provides specific contextual information associated with User Interface events.</p> |
| <p>To create an instance of the<code>UIEvent</code>interface, use the<code>DocumentEvent.createEvent("UIEvent")</code>method call.</p> |
| </descr> |
| <attribute type="views::AbstractView" name="view" readonly="yes" id="Events-UIEvent-view"> |
| <descr> |
| <p>The<code>view</code>attribute identifies the<code>AbstractView</code>from which the event was generated.</p> |
| </descr> |
| </attribute> |
| <attribute id="Events-UIEvent-detail" name="detail" type="long" readonly="yes"> |
| <descr> |
| <p>Specifies some detail information about the<code>Event</code>, depending on the type of event.</p> |
| </descr> |
| </attribute> |
| <method name="initUIEvent" id="Events-Event-initUIEvent"> |
| <descr> |
| <p>The<code>initUIEvent</code>method is used to initialize the value of a<code>UIEvent</code>object and has the same behavior as<code>Event.initEvent()</code>.</p> |
| </descr> |
| <parameters> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="viewArg" type="views::AbstractView" attr="in"> |
| <descr> |
| <p>Specifies<code>UIEvent.view</code>.</p> |
| </descr> |
| </param> |
| <param name="detailArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies<code>UIEvent.detail</code>.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="initUIEventNS" id="Events-Event-initUIEventNS" since="DOM Level 3"> |
| <descr> |
| <p>The<code>initUIEventNS</code>method is used to initialize the value of a<code>UIEvent</code>object and has the same behavior as<code>Event.initEventNS()</code>.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="viewArg" type="views::AbstractView" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="detailArg" type="long" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="TextEvent" inherits="UIEvent" id="Events-TextEvent" since="DOM Level 3"> |
| <descr> |
| <p>The<code>TextEvent</code>interface provides specific contextual information associated with Text Events.</p> |
| <p>To create an instance of the<code>TextEvent</code>interface, use the<code>DocumentEvent.createEvent("TextEvent")</code>method call.</p> |
| </descr> |
| <attribute type="DOMString" name="data" id="Events-UIEvent-data" readonly="yes"> |
| <descr> |
| <p><code>data</code>holds the value of the characters generated by the character device. This may be a single Unicode character or a non-empty sequence of Unicode characters<bibref ref="Unicode"/>. Characters should be normalized as defined by the Unicode normalization form<term>NFC</term>, defined in<bibref ref="UnicodeNormalization"/>. This attribute cannot be null or contain the empty string.</p> |
| </descr> |
| </attribute> |
| <method name="initTextEvent" id="Events-Event-initTextEvent"> |
| <descr> |
| <p>The<code>initTextEvent</code>method is used to initialize the value of a<code>TextEvent</code>object and has the same behavior as<code>UIEvent.initUIEvent()</code>. The value of<code>UIEvent.detail</code>remains undefined.</p> |
| </descr> |
| <parameters> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="viewArg" type="views::AbstractView" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="dataArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies<code>TextEvent.data</code>.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr/> |
| </returns> |
| <raises/> |
| </method> |
| <method name="initTextEventNS" id="Events-Event-initTextEventNS"> |
| <descr> |
| <p>The<code>initTextEventNS</code>method is used to initialize the value of a<code>TextEvent</code>object and has the same behavior as<code>UIEvent.initUIEventNS()</code>. The value of<code>UIEvent.detail</code>remains undefined.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="type" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="viewArg" type="views::AbstractView" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="dataArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>TextEvent.initTextEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr/> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="MouseEvent" inherits="UIEvent" id="Events-MouseEvent" since="DOM Level 2"> |
| <descr> |
| <p>The<code>MouseEvent</code>interface provides specific contextual information associated with Mouse events.</p> |
| <p>In the case of nested elements mouse events are always targeted at the most deeply nested element. Ancestors of the targeted element may use bubbling to obtain notification of mouse events which occur within theirs descendent elements.</p> |
| <p>To create an instance of the<code>MouseEvent</code>interface, use the<code>DocumentEvent.createEvent("MouseEvent")</code>method call.</p> |
| <note> |
| <p>When initializing<code>MouseEvent</code>objects using<code>initMouseEvent</code>or<code>initMouseEventNS</code>, implementations should use the client coordinates<code>clientX</code>and<code>clientY</code>for calculation of other coordinates (such as target coordinates exposed by<termref def="dt-DOM-Level-0">DOM Level 0</termref>implementations).</p> |
| </note> |
| </descr> |
| <attribute type="long" name="screenX" readonly="yes" id="Events-MouseEvent-screenX"> |
| <descr> |
| <p>The horizontal coordinate at which the event occurred relative to the origin of the screen coordinate system.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="screenY" readonly="yes" id="Events-MouseEvent-screenY"> |
| <descr> |
| <p>The vertical coordinate at which the event occurred relative to the origin of the screen coordinate system.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="clientX" readonly="yes" id="Events-MouseEvent-clientX"> |
| <descr> |
| <p>The horizontal coordinate at which the event occurred relative to the DOM implementation's client area.</p> |
| </descr> |
| </attribute> |
| <attribute type="long" name="clientY" readonly="yes" id="Events-MouseEvent-clientY"> |
| <descr> |
| <p>The vertical coordinate at which the event occurred relative to the DOM implementation's client area.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="ctrlKey" readonly="yes" id="Events-MouseEvent-ctrlKey"> |
| <descr> |
| <p><code>true</code>if the control (Ctrl) key modifier is activated.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="shiftKey" readonly="yes" id="Events-MouseEvent-shiftKey"> |
| <descr> |
| <p><code>true</code>if the shift (Shift) key modifier is activated.</p> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="altKey" readonly="yes" id="Events-MouseEvent-altKey"> |
| <descr> |
| <p><code>true</code>if the alt (alternative) key modifier is activated.</p> |
| <note> |
| <p>The Option key modifier on Macintosh systems must be represented using this key modifier.</p> |
| </note> |
| </descr> |
| </attribute> |
| <attribute type="boolean" name="metaKey" readonly="yes" id="Events-MouseEvent-metaKey"> |
| <descr> |
| <p><code>true</code>if the meta (Meta) key modifier is activated.</p> |
| <note> |
| <p>The Command key modifier on Macintosh system must be represented using this meta key.</p> |
| </note> |
| </descr> |
| </attribute> |
| <attribute type="unsigned short" name="button" readonly="yes" id="Events-MouseEvent-button"> |
| <descr> |
| <p>During mouse events caused by the depression or release of a mouse button,<code>button</code>is used to indicate which mouse button changed state.<code>0</code>indicates the normal button of the mouse (in general on the left or the one button on Macintosh mice, used to activate a button or select text).<code>2</code>indicates the contextual property (in general on the right, used to display a context menu) button of the mouse if present.<code>1</code>indicates the extra (in general in the middle and often combined with the mouse wheel) button. Some mice may provide or simulate more buttons, and values higher than<code>2</code>can be used to represent such buttons.</p> |
| </descr> |
| </attribute> |
| <attribute type="EventTarget" name="relatedTarget" readonly="yes" id="Events-MouseEvent-relatedTarget"> |
| <descr> |
| <p>Used to identify a secondary<code>EventTarget</code>related to a UI event. Currently this attribute is used with the mouseover event to indicate the<code>EventTarget</code>which the pointing device exited and with the mouseout event to indicate the<code>EventTarget</code>which the pointing device entered.</p> |
| </descr> |
| </attribute> |
| <method name="initMouseEvent" id="Events-Event-initMouseEvent"> |
| <descr> |
| <p>The<code>initMouseEvent</code>method is used to initialize the value of a<code>MouseEvent</code>object and has the same behavior as<code>UIEvent.initUIEvent()</code>.</p> |
| </descr> |
| <parameters> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="viewArg" type="views::AbstractView" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="detailArg" type="long" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="screenXArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies<code>MouseEvent.screenX</code>.</p> |
| </descr> |
| </param> |
| <param name="screenYArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies<code>MouseEvent.screenY</code>.</p> |
| </descr> |
| </param> |
| <param name="clientXArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies<code>MouseEvent.clientX</code>.</p> |
| </descr> |
| </param> |
| <param name="clientYArg" type="long" attr="in"> |
| <descr> |
| <p>Specifies<code>MouseEvent.clientY</code>.</p> |
| </descr> |
| </param> |
| <param name="ctrlKeyArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies<code>MouseEvent.ctrlKey</code>.</p> |
| </descr> |
| </param> |
| <param name="altKeyArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies<code>MouseEvent.altKey</code>.</p> |
| </descr> |
| </param> |
| <param name="shiftKeyArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies<code>MouseEvent.shiftKey</code>.</p> |
| </descr> |
| </param> |
| <param name="metaKeyArg" type="boolean" attr="in"> |
| <descr> |
| <p>Specifies<code>MouseEvent.metaKey</code>.</p> |
| </descr> |
| </param> |
| <param name="buttonArg" type="unsigned short" attr="in"> |
| <descr> |
| <p>Specifies<code>MouseEvent.button</code>.</p> |
| </descr> |
| </param> |
| <param name="relatedTargetArg" type="EventTarget" attr="in"> |
| <descr> |
| <p>Specifies<code>MouseEvent.relatedTarget</code>.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method id="Events-MouseEvent-getModifierState" name="getModifierState" since="DOM Level 3"> |
| <descr> |
| <p>This methods queries the state of a modifier using a key identifier. See also<specref ref="Modifiers"/>.</p> |
| </descr> |
| <parameters> |
| <param name="keyIdentifierArg" type="DOMString" attr="in"> |
| <descr> |
| <p>A modifier key identifier, as defined by the<code>KeyboardEvent.keyIdentifier</code>attribute. Common modifier keys are<code>"Alt"</code>,<code>"AltGraph"</code>,<code>"CapsLock"</code>,<code>"Control"</code>,<code>"Meta"</code>,<code>"NumLock"</code>,<code>"Scroll"</code>, or<code>"Shift"</code>.</p> |
| <note> |
| <p>If an application wishes to distinguish between right and left modifiers, this information could be deduced using keyboard events and<code>KeyboardEvent.keyLocation</code>.</p> |
| </note> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="boolean"> |
| <descr> |
| <p><code>true</code>if it is modifier key and the modifier is activated,<code>false</code>otherwise.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="initMouseEventNS" id="Events-Event-initMouseEventNS" since="DOM Level 3"> |
| <descr> |
| <p>The<code>initMouseEventNS</code>method is used to initialize the value of a<code>MouseEvent</code>object and has the same behavior as<code>UIEvent.initUIEventNS()</code>.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="viewArg" type="views::AbstractView" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="detailArg" type="long" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="screenXArg" type="long" attr="in"> |
| <descr> |
| <p>Refer to the<code>MouseEvent.initMouseEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="screenYArg" type="long" attr="in"> |
| <descr> |
| <p>Refer to the<code>MouseEvent.initMouseEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="clientXArg" type="long" attr="in"> |
| <descr> |
| <p>Refer to the<code>MouseEvent.initMouseEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="clientYArg" type="long" attr="in"> |
| <descr> |
| <p>Refer to the<code>MouseEvent.initMouseEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="buttonArg" type="unsigned short" attr="in"> |
| <descr> |
| <p>Refer to the<code>MouseEvent.initMouseEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="relatedTargetArg" type="EventTarget" attr="in"> |
| <descr> |
| <p>Refer to the<code>MouseEvent.initMouseEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="modifiersList" type="DOMString" attr="in"> |
| <descr> |
| <p>Aseparated list of modifier key identifiers to be activated on this object. As an example,<code>"Control Alt"</code>will activated the control and alt modifiers.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="KeyboardEvent" inherits="UIEvent" id="Events-KeyboardEvent" since="DOM Level 3"> |
| <descr> |
| <p>The<code>KeyboardEvent</code>interface provides specific contextual information associated with keyboard devices. Each keyboard event references a key using an identifier. Keyboard events are commonly directed at the element that has the focus.</p> |
| <p>The<code>KeyboardEvent</code>interface provides convenient attributes for some common modifiers keys:<code>KeyboardEvent.ctrlKey</code>,<code>KeyboardEvent.shiftKey</code>,<code>KeyboardEvent.altKey</code>,<code>KeyboardEvent.metaKey</code>. These attributes are equivalent to use the method<code>KeyboardEvent.getModifierState(keyIdentifierArg)</code>with "Control", "Shift", "Alt", or "Meta" respectively.</p> |
| <p>To create an instance of the<code>KeyboardEvent</code>interface, use the<code>DocumentEvent.createEvent("KeyboardEvent")</code>method call.</p> |
| </descr> |
| <group id="ID-KeyboardEvent-KeyLocationCode" name="KeyLocationCode"> |
| <descr> |
| <p>This set of constants is used to indicate the location of a key on the device. In case a DOM implementation wishes to provide a new location information, a value different from the following constant values must be used.</p> |
| </descr> |
| <constant name="DOM_KEY_LOCATION_STANDARD" id="DOM_KEY_LOCATION_STANDARD" type="unsigned long" value="0x00"> |
| <descr> |
| <p>The key activation is not distinguished as the left or right version of the key, and did not originate from the numeric keypad (or did not originate with a virtual key corresponding to the numeric keypad). Example: the 'Q' key on a PC 101 Key US keyboard.</p> |
| </descr> |
| </constant> |
| <constant name="DOM_KEY_LOCATION_LEFT" id="DOM_KEY_LOCATION_LEFT" type="unsigned long" value="0x01"> |
| <descr> |
| <p>The key activated is in the left key location (there is more than one possible location for this key). Example: the left Shift key on a PC 101 Key US keyboard.</p> |
| </descr> |
| </constant> |
| <constant name="DOM_KEY_LOCATION_RIGHT" id="DOM_KEY_LOCATION_RIGHT" type="unsigned long" value="0x02"> |
| <descr> |
| <p>The key activation is in the right key location (there is more than one possible location for this key). Example: the right Shift key on a PC 101 Key US keyboard.</p> |
| </descr> |
| </constant> |
| <constant name="DOM_KEY_LOCATION_NUMPAD" id="DOM_KEY_LOCATION_NUMPAD" type="unsigned long" value="0x03"> |
| <descr> |
| <p>The key activation originated on the numeric keypad or with a virtual key corresponding to the numeric keypad. Example: the '1' key on a PC 101 Key US keyboard located on the numeric pad.</p> |
| </descr> |
| </constant> |
| </group> |
| <attribute type="DOMString" name="keyIdentifier" id="Events-KeyboardEvent-keyIdentifier" readonly="yes"> |
| <descr> |
| <p><code>keyIdentifier</code>holds the identifier of the key. The key identifiers are defined in Appendix A.2 "<specref ref="KeySet-Set"/>". Implementations that are unable to identify a key must use the key identifier<code>"Unidentified"</code>.</p> |
| </descr> |
| </attribute> |
| <attribute id="Events-KeyboardEvent-keylocation" name="keyLocation" type="unsigned long" readonly="yes"> |
| <descr> |
| <p>The<code>keyLocation</code>attribute contains an indication of the location of they key on the device, as described in<specref ref="ID-KeyboardEvent-KeyLocationCode"/>.</p> |
| </descr> |
| </attribute> |
| <attribute name="ctrlKey" id="Events-KeyboardEvent-ctrlKey" type="boolean" readonly="yes"> |
| <descr> |
| <p><code>true</code>if the control (Ctrl) key modifier is activated.</p> |
| </descr> |
| </attribute> |
| <attribute name="shiftKey" id="Events-KeyboardEvent-shiftKey" type="boolean" readonly="yes"> |
| <descr> |
| <p><code>true</code>if the shift (Shift) key modifier is activated.</p> |
| </descr> |
| </attribute> |
| <attribute name="altKey" id="Events-KeyboardEvent-altKey" type="boolean" readonly="yes"> |
| <descr> |
| <p><code>true</code>if the alternative (Alt) key modifier is activated.</p> |
| <note> |
| <p>The Option key modifier on Macintosh systems must be represented using this key modifier.</p> |
| </note> |
| </descr> |
| </attribute> |
| <attribute name="metaKey" id="Events-KeyboardEvent-metaKey" type="boolean" readonly="yes"> |
| <descr> |
| <p><code>true</code>if the meta (Meta) key modifier is activated.</p> |
| <note> |
| <p>The Command key modifier on Macintosh systems must be represented using this key modifier.</p> |
| </note> |
| </descr> |
| </attribute> |
| <method id="Events-KeyboardEvent-getModifierState" name="getModifierState"> |
| <descr> |
| <p>This methods queries the state of a modifier using a key identifier. See also<specref ref="Modifiers"/>.</p> |
| </descr> |
| <parameters> |
| <param name="keyIdentifierArg" type="DOMString" attr="in"> |
| <descr> |
| <p>A modifier key identifier. Common modifier keys are<code>"Alt"</code>,<code>"AltGraph"</code>,<code>"CapsLock"</code>,<code>"Control"</code>,<code>"Meta"</code>,<code>"NumLock"</code>,<code>"Scroll"</code>, or<code>"Shift"</code>.</p> |
| <note> |
| <p>If an application wishes to distinguish between right and left modifiers, this information could be deduced using keyboard events and<code>KeyboardEvent.keyLocation</code>.</p> |
| </note> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="boolean"> |
| <descr> |
| <p><code>true</code>if it is modifier key and the modifier is activated,<code>false</code>otherwise.</p> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="initKeyboardEvent" id="Events-KeyboardEvent-initKeyboardEvent"> |
| <descr> |
| <p>The<code>initKeyboardEvent</code>method is used to initialize the value of a<code>KeyboardEvent</code>object and has the same behavior as<code>UIEvent.initUIEvent()</code>. The value of<code>UIEvent.detail</code>remains undefined.</p> |
| </descr> |
| <parameters> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="viewArg" type="views::AbstractView" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="keyIdentifierArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies<code>KeyboardEvent.keyIdentifier</code>.</p> |
| </descr> |
| </param> |
| <param name="keyLocationArg" type="unsigned long" attr="in"> |
| <descr> |
| <p>Specifies<code>KeyboardEvent.keyLocation</code>.</p> |
| </descr> |
| </param> |
| <param name="modifiersList" type="DOMString" attr="in"> |
| <descr> |
| <p>Aseparated list of modifier key identifiers to be activated on this object.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr/> |
| </returns> |
| <raises/> |
| </method> |
| <method name="initKeyboardEventNS" id="Events-KeyboardEvent-initKeyboardEventNS"> |
| <descr> |
| <p>The<code>initKeyboardEventNS</code>method is used to initialize the value of a<code>KeyboardEvent</code>object and has the same behavior as<code>UIEvent.initUIEventNS()</code>. The value of<code>UIEvent.detail</code>remains undefined.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="viewArg" type="views::AbstractView" attr="in"> |
| <descr> |
| <p>Refer to the<code>UIEvent.initUIEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="keyIdentifierArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>KeyboardEvent.initKeyboardEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="keyLocationArg" type="unsigned long" attr="in"> |
| <descr> |
| <p>Refer to the<code>KeyboardEvent.initKeyboardEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="modifiersList" type="DOMString" attr="in"> |
| <descr> |
| <p>Aseparated list of modifier key identifiers to be activated on this object. As an example,<code>"Control Alt"</code>will activated the control and alt modifiers.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr/> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="MutationEvent" inherits="Event" id="Events-MutationEvent" since="DOM Level 2"> |
| <descr> |
| <p>The<code>MutationEvent</code>interface provides specific contextual information associated with Mutation events.</p> |
| <p>To create an instance of the<code>MutationEvent</code>interface, use the<code>DocumentEvent.createEvent("MutationEvent")</code>method call.</p> |
| </descr> |
| <group id="Events-MutationEvent-attrChangeType" name="attrChangeType"> |
| <descr> |
| <p>An integer indicating in which way the<code>Attr</code>was changed.</p> |
| </descr> |
| <constant name="MODIFICATION" id="MODIFICATION" type="unsigned short" value="1"> |
| <descr> |
| <p>The<code>Attr</code>was modified in place.</p> |
| </descr> |
| </constant> |
| <constant name="ADDITION" id="ADDITION" type="unsigned short" value="2"> |
| <descr> |
| <p>The<code>Attr</code>was just added.</p> |
| </descr> |
| </constant> |
| <constant name="REMOVAL" id="REMOVAL" type="unsigned short" value="3"> |
| <descr> |
| <p>The<code>Attr</code>was just removed.</p> |
| </descr> |
| </constant> |
| </group> |
| <attribute type="Node" name="relatedNode" readonly="yes" id="Events-MutationEvent-relatedNode"> |
| <descr> |
| <p><code>relatedNode</code>is used to identify a secondary node related to a mutation event. For example, if a mutation event is dispatched to a node indicating that its parent has changed, the<code>relatedNode</code>is the changed parent. If an event is instead dispatched to a subtree indicating a node was changed within it, the<code>relatedNode</code>is the changed node. In the case of the<code>{"http://www.w3.org/2001/xml-events", "DOMAttrModified"}</code>event it indicates the<code>Attr</code>node which was modified, added, or removed.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="prevValue" readonly="yes" id="Events-MutationEvent-prevValue"> |
| <descr> |
| <p><code>prevValue</code>indicates the previous value of the<code>Attr</code>node in<code>{"http://www.w3.org/2001/xml-events", "DOMAttrModified"}</code>events, and of the<code>CharacterData</code>node in<code>{"http://www.w3.org/2001/xml-events", "DOMCharacterDataModified"}</code>events.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="newValue" readonly="yes" id="Events-MutationEvent-newValue"> |
| <descr> |
| <p><code>newValue</code>indicates the new value of the<code>Attr</code>node in<code>{"http://www.w3.org/2001/xml-events", "DOMAttrModified"}</code>events, and of the<code>CharacterData</code>node in<code>{"http://www.w3.org/2001/xml-events", "DOMCharacterDataModified"}</code>events.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="attrName" readonly="yes" id="Events-MutationEvent-attrName"> |
| <descr> |
| <p><code>attrName</code>indicates the name of the changed<code>Attr</code>node in a<code>{"http://www.w3.org/2001/xml-events", "DOMAttrModified"}</code>event.</p> |
| </descr> |
| </attribute> |
| <attribute type="unsigned short" name="attrChange" readonly="yes" id="Events-MutationEvent-attrChange"> |
| <descr> |
| <p><code>attrChange</code>indicates the type of change which triggered the<code>{"http://www.w3.org/2001/xml-events", "DOMAttrModified"}</code>event. The values can be<code>MODIFICATION</code>,<code>ADDITION</code>, or<code>REMOVAL</code>.</p> |
| </descr> |
| </attribute> |
| <method name="initMutationEvent" id="Events-Event-initMutationEvent"> |
| <descr> |
| <p>The<code>initMutationEvent</code>method is used to initialize the value of a<code>MutationEvent</code>object and has the same behavior as<code>Event.initEvent()</code>.</p> |
| </descr> |
| <parameters> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="relatedNodeArg" type="Node" attr="in"> |
| <descr> |
| <p>Specifies<code>MutationEvent.relatedNode</code>.</p> |
| </descr> |
| </param> |
| <param name="prevValueArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies<code>MutationEvent.prevValue</code>. This value may be null.</p> |
| </descr> |
| </param> |
| <param name="newValueArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies<code>MutationEvent.newValue</code>. This value may be null.</p> |
| </descr> |
| </param> |
| <param name="attrNameArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies<code>MutationEvent.attrname</code>. This value may be null.</p> |
| </descr> |
| </param> |
| <param name="attrChangeArg" type="unsigned short" attr="in"> |
| <descr> |
| <p>Specifies<code>MutationEvent.attrChange</code>. This value may be null.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="initMutationEventNS" id="Events-Event-initMutationEventNS" since="DOM Level 3"> |
| <descr> |
| <p>The<code>initMutationEventNS</code>method is used to initialize the value of a<code>MutationEvent</code>object and has the same behavior as<code>Event.initEventNS()</code>.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>Event.initEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="relatedNodeArg" type="Node" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="prevValueArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="newValueArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="attrNameArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="attrChangeArg" type="unsigned short" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| <interface name="MutationNameEvent" inherits="MutationEvent" id="Events-MutationNameEvent" since="DOM Level 3"> |
| <descr> |
| <p>The<code>MutationNameEvent</code>interface provides specific contextual information associated with Mutation name event types.</p> |
| <p>To create an instance of the<code>MutationNameEvent</code>interface, use the<code>Document.createEvent("MutationNameEvent")</code>method call.</p> |
| </descr> |
| <attribute type="DOMString" name="prevNamespaceURI" readonly="yes" id="Events-MutationNameEvent-prevNamespaceURI"> |
| <descr> |
| <p>The previous value of the<code>relatedNode</code>'s<code>namespaceURI</code>.</p> |
| </descr> |
| </attribute> |
| <attribute type="DOMString" name="prevNodeName" readonly="yes" id="Events-MutationNameEvent-prevNodeName"> |
| <descr> |
| <p>The previous value of the<code>relatedNode</code>'s<code>nodeName</code>.</p> |
| </descr> |
| </attribute> |
| <method name="initMutationNameEvent" id="Events-Event-initMutationNameEvent" since="DOM Level 3"> |
| <descr> |
| <p>The<code>initMutationNameEvent</code>method is used to initialize the value of a<code>MutationNameEvent</code>object and has the same behavior as<code>MutationEvent.initMutationEvent()</code>.</p> |
| </descr> |
| <parameters> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="relatedNodeArg" type="Node" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="prevNamespaceURIArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies<code>MutationNameEvent.prevNamespaceURI</code>. This value may be<code>null</code>.</p> |
| </descr> |
| </param> |
| <param name="prevNodeNameArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Specifies<code>MutationNameEvent.prevNodeName</code>.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| <method name="initMutationNameEventNS" id="Events-Event-initMutationNameEventNS" since="DOM Level 3"> |
| <descr> |
| <p>The<code>initMutationNameEventNS</code>method is used to initialize the value of a<code>MutationNameEvent</code>object and has the same behavior as<code>MutationEvent.initMutationEventNS()</code>.</p> |
| </descr> |
| <parameters> |
| <param name="namespaceURI" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="typeArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="canBubbleArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="cancelableArg" type="boolean" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="relatedNodeArg" type="Node" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEventNS()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="prevNamespaceURIArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| <param name="prevNodeNameArg" type="DOMString" attr="in"> |
| <descr> |
| <p>Refer to the<code>MutationEvent.initMutationEvent()</code>method for a description of this parameter.</p> |
| </descr> |
| </param> |
| </parameters> |
| <returns type="void"> |
| <descr> |
| <p/> |
| </descr> |
| </returns> |
| <raises/> |
| </method> |
| </interface> |
| </library> |
| /contrib/network/netsurf/libdom/test/leak-test.sh |
|---|
| 0,0 → 1,45 |
| #!/bin/bash |
| # |
| # This is a simple script used to test libdom memory leakage. |
| # Usage: |
| # You should firstly run "run-test.sh", which will genrate a test output directory. In that |
| # directory, there are C source files and corresponding executables. |
| # Go to the test output directory. For example , for core, level 1, it is output/level1/core |
| # And run this script as ../../../leak-test.sh "log-file" |
| # |
| # This file is part of libdom test suite. |
| # Licensed under the MIT License, |
| # http://www.opensource.org/licenses/mit-license.php |
| # Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| log=$1; |
| totla=0; |
| leak=0; |
| ok=0; |
| while read f; do |
| #Test defnitely lost |
| echo -n "$f: " >&3; |
| echo -n "$f: "; |
| dl=$(valgrind "$f" 2>&1 | grep "definitely lost" | sed -e 's/definitely lost//g' -e 's/bytes in//g' -e 's/blocks.//g' -e 's/^.*://g' -e 's/ //g' -e 's/,//g'); |
| pl=$(valgrind "$f" 2>&1 | grep "possibly lost" | sed -e 's/possibly lost//g' -e 's/bytes in//g' -e 's/blocks.//g' -e 's/^.*://g' -e 's/ //g' -e 's/,//g'); |
| total=$((total+1)); |
| if [ "$dl" -eq "00" -a "$pl" -eq "00" ]; then |
| echo "ok..." >&3; |
| echo "ok..."; |
| ok=$((ok+1)); |
| else |
| echo "leaked!" >&3; |
| echo "leaked!"; |
| leak=$((leak+1)); |
| fi |
| done 3>"$log" < <(find ./ -perm -o=x -type f -print); |
| echo "Total: $total" >>"$log"; |
| echo "Leak: $leak" >>"$log"; |
| echo "Ok: $ok" >>"$log"; |
| echo "Total: $total"; |
| echo "Leak: $leak"; |
| echo "Ok: $ok"; |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /contrib/network/netsurf/libdom/test/run-single-test.sh |
|---|
| 0,0 → 1,144 |
| #!/bin/bash |
| # |
| # This is a simple script to convert the a XML testcae to C source file, compile it, run it, and report the result. |
| # Usage: |
| # This script is designed to run under the libdom/test directory. |
| # |
| # domts="testcases" dtd="dom1-interfaces.xml" level="level1" ./run-single-test.sh |
| # |
| # The above command will convert the XML testcase in directory testcases/tests/level/core and |
| # use dom1-interfaces.xml to convert it. |
| # This script will generate a output/ directory in libdom/test, and in that directory, there is a same structure |
| # as in DOMTS XML testcases files. |
| # |
| # This file is part of libdom test suite. |
| # Licensed under the MIT License, |
| # http://www.opensource.org/licenses/mit-license.php |
| # Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| level=${level:-"level1"}; |
| module=${module:-"core"}; |
| domts=${domts:?"The \$domts must be assigned some value"}; |
| output=${output:-"output"}; |
| dtd=${dtd:?"The DTD file must be given"}; |
| testdir="$domts"/tests/"$level"/"$module" |
| log="$output"/"$level"/"$module"/test.log; |
| src="testutils/comparators.c testutils/domtsasserts.c testutils/foreach.c testutils/list.c testutils/load.c testutils/utils.c testutils/domtscondition.c" |
| domdir="../build-Linux-Linux-debug-lib-static" |
| ldflags="-L$domdir -ldom -L/usr/local/lib -lwapcaplet -L/usr/lib -lxml2 -lhubbub -lparserutils" |
| #ldflags="-L/usr/lib -lm -lz -L$domdir -ldom -L/usr/local/lib -lwapcaplet -lxml2 -lhubbub -lparserutils" |
| cflags="-Itestutils/ -I../bindings/xml -I../include -I../bindings/hubbub -I/usr/local/include" |
| total=0; |
| fail=0; |
| pass=0; |
| conversion=0; |
| compile=0; |
| run=0; |
| nsupport=0; |
| # Create the directories if necessary |
| if [ ! -e "$ouput" ]; then |
| mkdir -p "$output"; |
| fi |
| if [ ! -e "$level" ]; then |
| mkdir -p "$output"/"$level"; |
| fi |
| if [ ! -e "$module" ]; then |
| mkdir -p "$output"/"$level"/"$module"; |
| fi |
| # Prepare the test files |
| if [ -e "files" ]; then |
| rm -fr files; |
| fi |
| cp -fr "$testdir/files" ./; |
| while read test; do |
| total=$(($total+1)); |
| file=`basename "$test"`; |
| name=${file%%.xml}; |
| cfile="$output"/"$level"/"$module"/"$name".c; |
| ofile="$output"/"$level"/"$module"/"$name"; |
| tfile="$testdir"/"$file"; |
| echo -n "$file:"; |
| # Generate the test C program |
| out=`perl transform.pl "$dtd" "$tfile" 2>&1 >"${cfile}.unindent"`; |
| if [ "$?" != "0" ]; then |
| fail=$((fail+1)); |
| conversion=$((conversion+1)); |
| echo "$tfile Conversion Error:" >& 3; |
| echo "Please make sure you have XML::XPath perl module installed!" >& 3; |
| echo "$out" >&3; |
| echo -e "----------------------------------------\n\n" >& 3; |
| echo "failed!"; |
| rm -fr "${cfile}.unindent"; |
| continue; |
| fi |
| out=`indent "${cfile}.unindent" -o "$cfile" 2>&1`; |
| if [ "$?" != "0" ]; then |
| rm -fr "${cfile}.unindent"; |
| fail=$((fail+1)); |
| conversion=$((conversion+1)); |
| echo "$tfile Conversion Error:" >& 3; |
| echo "$out" >& 3; |
| echo -e "----------------------------------------\n\n" >& 3; |
| echo "failed!"; |
| continue; |
| fi |
| rm -fr "${cfile}.unindent"; |
| # Compile it now |
| out=` ( gcc -g $cflags $src $cfile $ldflags -o "$ofile" ) 2>&1`; |
| if [ "$?" != "0" ]; then |
| fail=$((fail+1)); |
| compile=$((compile+1)); |
| echo "$tfile Compile Error:" >& 3; |
| echo "$out" >& 3; |
| echo -e "----------------------------------------\n\n" >& 3; |
| echo "failed!"; |
| continue; |
| fi |
| # Run the test and test the result |
| cd files; |
| out=$(../$ofile 2>&1); |
| ret="$?"; |
| if [ "$ret" != "0" ]; then |
| cd ..; |
| fail=$((fail+1)); |
| if [ "$ret" == "9" ]; then |
| nsupport=$((nsupport+1)) |
| echo "$tfile Not Support:" >& 3; |
| echo "$out" >& 3; |
| echo -e "----------------------------------------\n\n" >& 3; |
| echo "not supported!"; |
| else |
| run=$((run+1)); |
| echo "$tfile Run Error:" >& 3; |
| echo "$out" >& 3; |
| echo -e "----------------------------------------\n\n" >& 3; |
| echo "failed!"; |
| fi |
| continue; |
| fi |
| cd ..; |
| pass=$((pass+1)); |
| echo "passed."; |
| done 3>&1 < <(echo $1); |
| echo "Total: $total"; |
| echo "Passed: $pass"; |
| echo "Failed: $fail"; |
| echo "Conversion Error: $conversion"; |
| echo "Compile Error: $compile"; |
| echo "Run Error: $run"; |
| echo "Not Support: $nsupport"; |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /contrib/network/netsurf/libdom/test/run-test.sh |
|---|
| 0,0 → 1,145 |
| #!/bin/bash |
| # |
| # This is a simple script to convert the XML testcaes to C source file, compile it, run it, and report the result. |
| # Usage: |
| # This script is designed to run under the libdom/test directory. |
| # |
| # domts="testcases" dtd="dom1-interfaces.xml" level="level1" ./run-test.sh |
| # |
| # The above command will convert the XML testcase in directory testcases/tests/level/core and |
| # use dom1-interfaces.xml to convert it. |
| # This script will generate a output/ directory in libdom/test, and in that directory, there is a same structure |
| # as in DOMTS XML testcases files. |
| # |
| # This file is part of libdom test suite. |
| # Licensed under the MIT License, |
| # http://www.opensource.org/licenses/mit-license.php |
| # Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| level=${level:-"level1"}; |
| module=${module:-"core"}; |
| domts=${domts:?"The \$domts must be assigned some value"}; |
| output=${output:-"output"}; |
| dtd=${dtd:?"The DTD file must be given"}; |
| testdir="$domts"/tests/"$level"/"$module" |
| log="$output"/"$level"/"$module"/test.log; |
| src="testutils/comparators.c testutils/domtsasserts.c testutils/foreach.c testutils/list.c testutils/load.c testutils/utils.c testutils/domtscondition.c" |
| domdir="../build-Linux-Linux-debug-lib-static" |
| ldflags="-L$libdir -L$libdir -lxml2 $(pkg-config --libs libdom libwapcaplet libparserutils libhubbub)" |
| cflags="-Itestutils/ -I../bindings/xml -I../include -I../bindings/hubbub $(pkg-config --cflags libwapcaplet libparserutils libhubbub)" |
| total=0; |
| fail=0; |
| pass=0; |
| conversion=0; |
| compile=0; |
| run=0; |
| nsupport=0; |
| # Create the directories if necessary |
| if [ ! -e "$ouput" ]; then |
| mkdir -p "$output"; |
| fi |
| if [ ! -e "$level" ]; then |
| mkdir -p "$output"/"$level"; |
| fi |
| if [ ! -e "$module" ]; then |
| mkdir -p "$output"/"$level"/"$module"; |
| fi |
| # Prepare the test files |
| if [ -e "files" ]; then |
| rm -fr files; |
| fi |
| cp -fr "$testdir/files" ./; |
| while read test; do |
| total=$(($total+1)); |
| file=`basename "$test"`; |
| name=${file%%.xml}; |
| cfile="$output"/"$level"/"$module"/"$name".c; |
| ofile="$output"/"$level"/"$module"/"$name"; |
| tfile="$testdir"/"$file"; |
| echo -n "$file:"; |
| # Generate the test C program |
| out=`perl transform.pl "$dtd" "$tfile" 2>&1 >"${cfile}.unindent"`; |
| if [ "$?" != "0" ]; then |
| fail=$((fail+1)); |
| conversion=$((conversion+1)); |
| echo "$tfile Conversion Error:" >& 3; |
| echo "Please make sure you have XML::XPath perl module installed!" >& 3; |
| echo "$out" >&3; |
| echo -e "----------------------------------------\n\n" >& 3; |
| echo "failed!"; |
| rm -fr "${cfile}.unindent"; |
| continue; |
| fi |
| out=`indent "${cfile}.unindent" -o "$cfile" 2>&1`; |
| if [ "$?" != "0" ]; then |
| rm -fr "${cfile}.unindent"; |
| fail=$((fail+1)); |
| conversion=$((conversion+1)); |
| echo "$tfile Conversion Error:" >& 3; |
| echo "$out" >& 3; |
| echo -e "----------------------------------------\n\n" >& 3; |
| echo "failed!"; |
| continue; |
| fi |
| rm -fr "${cfile}.unindent"; |
| # Compile it now |
| out=` ( gcc -g $cflags $src $cfile $ldflags -o "$ofile" ) 2>&1`; |
| if [ "$?" != "0" ]; then |
| fail=$((fail+1)); |
| compile=$((compile+1)); |
| echo "$tfile Compile Error:" >& 3; |
| echo "$out" >& 3; |
| echo -e "----------------------------------------\n\n" >& 3; |
| echo "failed!"; |
| continue; |
| fi |
| # Run the test and test the result |
| cd files; |
| out=$(../$ofile 2>&1); |
| ret="$?"; |
| if [ "$ret" != "0" ]; then |
| cd ..; |
| fail=$((fail+1)); |
| if [ "$ret" == "9" ]; then |
| nsupport=$((nsupport+1)) |
| echo "$tfile Not Support:" >& 3; |
| echo "$out" >& 3; |
| echo -e "----------------------------------------\n\n" >& 3; |
| echo "not supported!"; |
| else |
| run=$((run+1)); |
| echo "$tfile Run Error:" >& 3; |
| echo "$out" >& 3; |
| echo -e "----------------------------------------\n\n" >& 3; |
| echo "failed!"; |
| fi |
| continue; |
| fi |
| cd ..; |
| pass=$((pass+1)); |
| echo "passed."; |
| done 3>"$log" < <(perl -ne 'if ($_ =~ /href=\"(.*\.xml)\"/) { print "$1\n"; }' -- "$testdir"/alltests.xml); |
| echo "Total: $total" | tee >>"$log"; |
| echo "Passed: $pass" | tee >>"$log"; |
| echo "Failed: $fail" | tee >>"$log"; |
| echo "Conversion Error: $conversion" | tee >>"$log"; |
| echo "Compile Error: $compile" | tee >>"$log"; |
| echo "Run Error: $run" | tee >>"$log"; |
| echo "Not Support: $nsupport" | tee >>"$log"; |
| cat "$log"; |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /contrib/network/netsurf/libdom/test/testcases/tests/CVS/Entries |
|---|
| 0,0 → 1,5 |
| D/level1//// |
| D/level2//// |
| D/level3//// |
| D/submittedtests//// |
| D/validation//// |
| /contrib/network/netsurf/libdom/test/testcases/tests/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests |
| /contrib/network/netsurf/libdom/test/testcases/tests/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/CVS/Template |
|---|
| --- test/testcases/tests/level1/CVS/Entries (nonexistent) |
| +++ test/testcases/tests/level1/CVS/Entries (revision 4364) |
| @@ -0,0 +1,2 @@ |
| +D/core//// |
| +D/html//// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level1 |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/CVS/Template |
|---|
| --- test/testcases/tests/level1/core/.cvsignore (nonexistent) |
| +++ test/testcases/tests/level1/core/.cvsignore (revision 4364) |
| @@ -0,0 +1,2 @@ |
| +dom1.dtd |
| +dom1.xsd |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/CVS/Entries |
|---|
| 0,0 → 1,531 |
| D/files//// |
| /.cvsignore/1.1/Fri Apr 3 02:48:04 2009// |
| /alltests.xml/1.22/Fri Apr 3 02:48:03 2009// |
| /attrcreatedocumentfragment.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /attrcreatetextnode.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /attrcreatetextnode2.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /attrdefaultvalue.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /attreffectivevalue.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /attrentityreplacement.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /attrname.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /attrnextsiblingnull.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /attrnotspecifiedvalue.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /attrparentnodenull.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /attrprevioussiblingnull.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /attrremovechild1.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /attrreplacechild1.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /attrsetvaluenomodificationallowederr.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /attrsetvaluenomodificationallowederrEE.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /attrspecifiedvalue.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /attrspecifiedvaluechanged.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /attrspecifiedvalueremove.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /cdatasectiongetdata.xml/1.13/Fri Apr 3 02:48:03 2009// |
| /cdatasectionnormalize.xml/1.11/Fri Apr 3 02:48:03 2009// |
| /characterdataappenddata.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /characterdataappenddatagetdata.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /characterdataappenddatanomodificationallowederr.xml/1.12/Fri Apr 3 02:48:04 2009// |
| /characterdataappenddatanomodificationallowederrEE.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /characterdatadeletedatabegining.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /characterdatadeletedataend.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /characterdatadeletedataexceedslength.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /characterdatadeletedatagetlengthanddata.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /characterdatadeletedatamiddle.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /characterdatadeletedatanomodificationallowederr.xml/1.12/Fri Apr 3 02:48:04 2009// |
| /characterdatadeletedatanomodificationallowederrEE.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /characterdatagetdata.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /characterdatagetlength.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /characterdataindexsizeerrdeletedatacountnegative.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /characterdataindexsizeerrdeletedataoffsetgreater.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /characterdataindexsizeerrdeletedataoffsetnegative.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /characterdataindexsizeerrinsertdataoffsetgreater.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /characterdataindexsizeerrinsertdataoffsetnegative.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /characterdataindexsizeerrreplacedatacountnegative.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /characterdataindexsizeerrreplacedataoffsetgreater.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /characterdataindexsizeerrreplacedataoffsetnegative.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /characterdataindexsizeerrsubstringcountnegative.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /characterdataindexsizeerrsubstringnegativeoffset.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /characterdataindexsizeerrsubstringoffsetgreater.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /characterdatainsertdatabeginning.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /characterdatainsertdataend.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /characterdatainsertdatamiddle.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /characterdatainsertdatanomodificationallowederr.xml/1.12/Fri Apr 3 02:48:04 2009// |
| /characterdatainsertdatanomodificationallowederrEE.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /characterdatareplacedatabegining.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /characterdatareplacedataend.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /characterdatareplacedataexceedslengthofarg.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /characterdatareplacedataexceedslengthofdata.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /characterdatareplacedatamiddle.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /characterdatareplacedatanomodificationallowederr.xml/1.13/Fri Apr 3 02:48:03 2009// |
| /characterdatareplacedatanomodificationallowederrEE.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /characterdatasetdatanomodificationallowederr.xml/1.11/Fri Apr 3 02:48:04 2009// |
| /characterdatasetdatanomodificationallowederrEE.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /characterdatasetnodevalue.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /characterdatasubstringexceedsvalue.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /characterdatasubstringvalue.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /commentgetcomment.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /documentcreateattribute.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /documentcreatecdatasection.xml/1.12/Fri Apr 3 02:48:04 2009// |
| /documentcreatecomment.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /documentcreatedocumentfragment.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /documentcreateelement.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /documentcreateelementcasesensitive.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /documentcreateelementdefaultattr.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /documentcreateentityreference.xml/1.15/Fri Apr 3 02:48:04 2009// |
| /documentcreateentityreferenceknown.xml/1.14/Fri Apr 3 02:48:04 2009// |
| /documentcreateprocessinginstruction.xml/1.12/Fri Apr 3 02:48:03 2009// |
| /documentcreatetextnode.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /documentgetdoctype.xml/1.13/Fri Apr 3 02:48:04 2009// |
| /documentgetdoctypenodtd.xml/1.10/Fri Apr 3 02:48:04 2009// |
| /documentgetelementsbytagnamelength.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /documentgetelementsbytagnametotallength.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /documentgetelementsbytagnamevalue.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /documentgetimplementation.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /documentgetrootnode.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /documentinvalidcharacterexceptioncreateattribute.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /documentinvalidcharacterexceptioncreateelement.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /documentinvalidcharacterexceptioncreateentref.xml/1.13/Fri Apr 3 02:48:04 2009// |
| /documentinvalidcharacterexceptioncreateentref1.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /documentinvalidcharacterexceptioncreatepi.xml/1.13/Fri Apr 3 02:48:03 2009// |
| /documentinvalidcharacterexceptioncreatepi1.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /documenttypegetdoctype.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /documenttypegetentities.xml/1.13/Fri Apr 3 02:48:03 2009// |
| /documenttypegetentitieslength.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /documenttypegetentitiestype.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /documenttypegetnotations.xml/1.10/Fri Apr 3 02:48:04 2009// |
| /documenttypegetnotationstype.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /domimplementationfeaturenoversion.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /domimplementationfeaturenull.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /domimplementationfeaturexml.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /elementaddnewattribute.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /elementassociatedattribute.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /elementchangeattributevalue.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /elementcreatenewattribute.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /elementgetattributenode.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /elementgetattributenodenull.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /elementgetelementempty.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /elementgetelementsbytagname.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /elementgetelementsbytagnameaccessnodelist.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /elementgetelementsbytagnamenomatch.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /elementgetelementsbytagnamespecialvalue.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /elementgettagname.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /elementinuseattributeerr.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /elementinvalidcharacterexception.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /elementnormalize.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /elementnotfounderr.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /elementremoveattribute.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /elementremoveattributeaftercreate.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /elementremoveattributenode.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /elementremoveattributenodenomodificationallowederr.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /elementremoveattributenodenomodificationallowederrEE.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /elementremoveattributenomodificationallowederr.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /elementremoveattributenomodificationallowederrEE.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /elementremoveattributerestoredefaultvalue.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /elementreplaceattributewithself.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /elementreplaceexistingattribute.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /elementreplaceexistingattributegevalue.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /elementretrieveallattributes.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /elementretrieveattrvalue.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /elementretrievetagname.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /elementsetattributenodenomodificationallowederr.xml/1.12/Fri Apr 3 02:48:03 2009// |
| /elementsetattributenodenomodificationallowederrEE.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /elementsetattributenodenull.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /elementsetattributenomodificationallowederr.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /elementsetattributenomodificationallowederrEE.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /elementwrongdocumenterr.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /entitygetentityname.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /entitygetpublicid.xml/1.12/Fri Apr 3 02:48:03 2009// |
| /entitygetpublicidnull.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /hc_attrappendchild1.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrappendchild2.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrappendchild3.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrappendchild4.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrappendchild5.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_attrappendchild6.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_attrchildnodes1.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrchildnodes2.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrclonenode1.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrcreatedocumentfragment.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /hc_attrcreatetextnode.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrcreatetextnode2.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_attreffectivevalue.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrfirstchild.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrgetvalue1.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrgetvalue2.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrhaschildnodes.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_attrinsertbefore1.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrinsertbefore2.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrinsertbefore3.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_attrinsertbefore4.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrinsertbefore5.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_attrinsertbefore6.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrinsertbefore7.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrlastchild.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrname.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /hc_attrnextsiblingnull.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_attrnormalize.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_attrparentnodenull.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrprevioussiblingnull.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrremovechild1.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrremovechild2.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_attrreplacechild1.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrreplacechild2.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_attrsetvalue1.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_attrsetvalue2.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_attrspecifiedvalue.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_attrspecifiedvaluechanged.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_characterdataappenddata.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_characterdataappenddatagetdata.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_characterdatadeletedatabegining.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_characterdatadeletedataend.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_characterdatadeletedataexceedslength.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_characterdatadeletedatagetlengthanddata.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_characterdatadeletedatamiddle.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_characterdatagetdata.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_characterdatagetlength.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_characterdataindexsizeerrdeletedatacountnegative.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_characterdataindexsizeerrdeletedataoffsetgreater.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_characterdataindexsizeerrdeletedataoffsetnegative.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_characterdataindexsizeerrinsertdataoffsetgreater.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_characterdataindexsizeerrinsertdataoffsetnegative.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_characterdataindexsizeerrreplacedatacountnegative.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_characterdataindexsizeerrreplacedataoffsetgreater.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_characterdataindexsizeerrreplacedataoffsetnegative.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_characterdataindexsizeerrsubstringcountnegative.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_characterdataindexsizeerrsubstringnegativeoffset.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_characterdataindexsizeerrsubstringoffsetgreater.xml/1.4/Fri Apr 3 02:48:04 2009// |
| /hc_characterdatainsertdatabeginning.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_characterdatainsertdataend.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_characterdatainsertdatamiddle.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_characterdatareplacedatabegining.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_characterdatareplacedataend.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_characterdatareplacedataexceedslengthofarg.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_characterdatareplacedataexceedslengthofdata.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_characterdatareplacedatamiddle.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_characterdatasetnodevalue.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_characterdatasubstringexceedsvalue.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_characterdatasubstringvalue.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_commentgetcomment.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_documentcreateattribute.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /hc_documentcreatecomment.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_documentcreatedocumentfragment.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_documentcreateelement.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_documentcreateelementcasesensitive.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /hc_documentcreatetextnode.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_documentgetdoctype.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_documentgetelementsbytagnamelength.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_documentgetelementsbytagnametotallength.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /hc_documentgetelementsbytagnamevalue.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_documentgetimplementation.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_documentgetrootnode.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_documentinvalidcharacterexceptioncreateattribute.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_documentinvalidcharacterexceptioncreateattribute1.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_documentinvalidcharacterexceptioncreateelement.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_documentinvalidcharacterexceptioncreateelement1.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_domimplementationfeaturenoversion.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_domimplementationfeaturenull.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_domimplementationfeaturexml.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_elementaddnewattribute.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_elementassociatedattribute.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_elementchangeattributevalue.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_elementcreatenewattribute.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_elementgetattributenode.xml/1.4/Fri Apr 3 02:48:04 2009// |
| /hc_elementgetattributenodenull.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_elementgetelementempty.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_elementgetelementsbytagname.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_elementgetelementsbytagnameaccessnodelist.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_elementgetelementsbytagnamenomatch.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_elementgetelementsbytagnamespecialvalue.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /hc_elementgettagname.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_elementinuseattributeerr.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /hc_elementinvalidcharacterexception.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_elementinvalidcharacterexception1.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_elementnormalize.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_elementnormalize2.xml/1.4/Fri Apr 3 02:48:04 2009// |
| /hc_elementnotfounderr.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_elementremoveattribute.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_elementremoveattributeaftercreate.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_elementremoveattributenode.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_elementreplaceattributewithself.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_elementreplaceexistingattribute.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_elementreplaceexistingattributegevalue.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_elementretrieveallattributes.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /hc_elementretrieveattrvalue.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_elementretrievetagname.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_elementsetattributenodenull.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_elementwrongdocumenterr.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_entitiesremovenameditem1.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_entitiessetnameditem1.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_namednodemapchildnoderange.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /hc_namednodemapgetnameditem.xml/1.4/Fri Apr 3 02:48:04 2009// |
| /hc_namednodemapinuseattributeerr.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_namednodemapnotfounderr.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_namednodemapnumberofnodes.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /hc_namednodemapremovenameditem.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_namednodemapreturnattrnode.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /hc_namednodemapreturnfirstitem.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /hc_namednodemapreturnlastitem.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /hc_namednodemapreturnnull.xml/1.4/Fri Apr 3 02:48:04 2009// |
| /hc_namednodemapsetnameditem.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /hc_namednodemapsetnameditemreturnvalue.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_namednodemapsetnameditemthatexists.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_namednodemapsetnameditemwithnewvalue.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_namednodemapwrongdocumenterr.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_nodeappendchild.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_nodeappendchildchildexists.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_nodeappendchilddocfragment.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /hc_nodeappendchildgetnodename.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_nodeappendchildinvalidnodetype.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodeappendchildnewchilddiffdocument.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodeappendchildnodeancestor.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodeattributenodeattribute.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodeattributenodename.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /hc_nodeattributenodetype.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodeattributenodevalue.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodechildnodes.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_nodechildnodesappendchild.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_nodechildnodesempty.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodecloneattributescopied.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /hc_nodeclonefalsenocopytext.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_nodeclonegetparentnull.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodeclonenodefalse.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodeclonenodetrue.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /hc_nodeclonetruecopytext.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodecommentnodeattributes.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_nodecommentnodename.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodecommentnodetype.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodecommentnodevalue.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodedocumentfragmentnodename.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodedocumentfragmentnodetype.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodedocumentfragmentnodevalue.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodedocumentnodeattribute.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodedocumentnodename.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodedocumentnodetype.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodedocumentnodevalue.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodeelementnodeattributes.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /hc_nodeelementnodename.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_nodeelementnodetype.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_nodeelementnodevalue.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodegetfirstchild.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodegetfirstchildnull.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodegetlastchild.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_nodegetlastchildnull.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodegetnextsibling.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_nodegetnextsiblingnull.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodegetownerdocument.xml/1.4/Fri Apr 3 02:48:04 2009// |
| /hc_nodegetownerdocumentnull.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodegetprevioussibling.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodegetprevioussiblingnull.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_nodehaschildnodes.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_nodehaschildnodesfalse.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodeinsertbefore.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /hc_nodeinsertbeforedocfragment.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_nodeinsertbeforeinvalidnodetype.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_nodeinsertbeforenewchilddiffdocument.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodeinsertbeforenewchildexists.xml/1.4/Fri Apr 3 02:48:04 2009// |
| /hc_nodeinsertbeforenodeancestor.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_nodeinsertbeforenodename.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_nodeinsertbeforerefchildnonexistent.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodeinsertbeforerefchildnull.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_nodelistindexequalzero.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_nodelistindexgetlength.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodelistindexgetlengthofemptylist.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodelistindexnotzero.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /hc_nodelistreturnfirstitem.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodelistreturnlastitem.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodelisttraverselist.xml/1.4/Fri Apr 3 02:48:04 2009// |
| /hc_nodeparentnode.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodeparentnodenull.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_noderemovechild.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_noderemovechildgetnodename.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_noderemovechildnode.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /hc_noderemovechildoldchildnonexistent.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodereplacechild.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_nodereplacechildinvalidnodetype.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_nodereplacechildnewchilddiffdocument.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodereplacechildnewchildexists.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /hc_nodereplacechildnodeancestor.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_nodereplacechildnodename.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodereplacechildoldchildnonexistent.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodetextnodeattribute.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodetextnodename.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_nodetextnodetype.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_nodetextnodevalue.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_nodevalue01.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodevalue02.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_nodevalue03.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /hc_nodevalue04.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /hc_nodevalue05.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_nodevalue06.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_nodevalue07.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /hc_nodevalue08.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /hc_notationsremovenameditem1.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /hc_notationssetnameditem1.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /hc_textindexsizeerrnegativeoffset.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /hc_textindexsizeerroffsetoutofbounds.xml/1.2/Fri Apr 3 02:48:04 2009// |
| /hc_textparseintolistofelements.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /hc_textsplittextfour.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /hc_textsplittextone.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_textsplittextthree.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_textsplittexttwo.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /hc_textwithnomarkup.xml/1.1/Fri Apr 3 02:48:04 2009// |
| /metadata.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /namednodemapchildnoderange.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /namednodemapgetnameditem.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /namednodemapinuseattributeerr.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /namednodemapnotfounderr.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /namednodemapnumberofnodes.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /namednodemapremovenameditem.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /namednodemapremovenameditemgetvalue.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /namednodemapremovenameditemreturnnodevalue.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /namednodemapreturnattrnode.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /namednodemapreturnfirstitem.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /namednodemapreturnlastitem.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /namednodemapreturnnull.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /namednodemapsetnameditem.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /namednodemapsetnameditemreturnvalue.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /namednodemapsetnameditemthatexists.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /namednodemapsetnameditemwithnewvalue.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /namednodemapwrongdocumenterr.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodeappendchild.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodeappendchildchildexists.xml/1.10/Fri Apr 3 02:48:04 2009// |
| /nodeappendchilddocfragment.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodeappendchildgetnodename.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodeappendchildinvalidnodetype.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodeappendchildnewchilddiffdocument.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodeappendchildnodeancestor.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /nodeappendchildnomodificationallowederr.xml/1.10/Fri Apr 3 02:48:04 2009// |
| /nodeappendchildnomodificationallowederrEE.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodeattributenodeattribute.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodeattributenodename.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /nodeattributenodetype.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodeattributenodevalue.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodecdatasectionnodeattribute.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /nodecdatasectionnodename.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodecdatasectionnodetype.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /nodecdatasectionnodevalue.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodechildnodes.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodechildnodesappendchild.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodechildnodesempty.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodecloneattributescopied.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodeclonefalsenocopytext.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /nodeclonegetparentnull.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodeclonenodefalse.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /nodeclonenodetrue.xml/1.10/Fri Apr 3 02:48:04 2009// |
| /nodeclonetruecopytext.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /nodecommentnodeattributes.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /nodecommentnodename.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /nodecommentnodetype.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /nodecommentnodevalue.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodedocumentfragmentnodename.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodedocumentfragmentnodetype.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodedocumentfragmentnodevalue.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodedocumentnodeattribute.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodedocumentnodename.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodedocumentnodetype.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /nodedocumentnodevalue.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodedocumenttypenodename.xml/1.10/Fri Apr 3 02:48:04 2009// |
| /nodedocumenttypenodetype.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodedocumenttypenodevalue.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodeelementnodeattributes.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodeelementnodename.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodeelementnodetype.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodeelementnodevalue.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodeentitynodeattributes.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodeentitynodename.xml/1.11/Fri Apr 3 02:48:04 2009// |
| /nodeentitynodetype.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /nodeentitynodevalue.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /nodeentityreferencenodeattributes.xml/1.12/Fri Apr 3 02:48:04 2009// |
| /nodeentityreferencenodename.xml/1.12/Fri Apr 3 02:48:03 2009// |
| /nodeentityreferencenodetype.xml/1.12/Fri Apr 3 02:48:04 2009// |
| /nodeentityreferencenodevalue.xml/1.12/Fri Apr 3 02:48:04 2009// |
| /nodeentitysetnodevalue.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodegetfirstchild.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodegetfirstchildnull.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /nodegetlastchild.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /nodegetlastchildnull.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodegetnextsibling.xml/1.10/Fri Apr 3 02:48:04 2009// |
| /nodegetnextsiblingnull.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodegetownerdocument.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /nodegetownerdocumentnull.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /nodegetprevioussibling.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodegetprevioussiblingnull.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /nodehaschildnodes.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /nodehaschildnodesfalse.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodeinsertbefore.xml/1.10/Fri Apr 3 02:48:04 2009// |
| /nodeinsertbeforedocfragment.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodeinsertbeforeinvalidnodetype.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodeinsertbeforenewchilddiffdocument.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodeinsertbeforenewchildexists.xml/1.10/Fri Apr 3 02:48:04 2009// |
| /nodeinsertbeforenodeancestor.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodeinsertbeforenodename.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /nodeinsertbeforenomodificationallowederr.xml/1.11/Fri Apr 3 02:48:03 2009// |
| /nodeinsertbeforenomodificationallowederrEE.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /nodeinsertbeforerefchildnonexistent.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodeinsertbeforerefchildnull.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodelistindexequalzero.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /nodelistindexgetlength.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodelistindexgetlengthofemptylist.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodelistindexnotzero.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodelistreturnfirstitem.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodelistreturnlastitem.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodelisttraverselist.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /nodenotationnodeattributes.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /nodenotationnodename.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodenotationnodetype.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /nodenotationnodevalue.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /nodeparentnode.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodeparentnodenull.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodeprocessinginstructionnodeattributes.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /nodeprocessinginstructionnodename.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodeprocessinginstructionnodetype.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /nodeprocessinginstructionnodevalue.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodeprocessinginstructionsetnodevalue.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /noderemovechild.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /noderemovechildgetnodename.xml/1.10/Fri Apr 3 02:48:03 2009// |
| /noderemovechildnode.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /noderemovechildnomodificationallowederr.xml/1.11/Fri Apr 3 02:48:04 2009// |
| /noderemovechildnomodificationallowederrEE.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /noderemovechildoldchildnonexistent.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodereplacechild.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /nodereplacechildinvalidnodetype.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodereplacechildnewchilddiffdocument.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodereplacechildnewchildexists.xml/1.11/Fri Apr 3 02:48:04 2009// |
| /nodereplacechildnodeancestor.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodereplacechildnodename.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /nodereplacechildnomodificationallowederr.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /nodereplacechildnomodificationallowederrEE.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodereplacechildoldchildnonexistent.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodesetnodevaluenomodificationallowederr.xml/1.12/Fri Apr 3 02:48:03 2009// |
| /nodesetnodevaluenomodificationallowederrEE.xml/1.9/Fri Apr 3 02:48:03 2009// |
| /nodetextnodeattribute.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodetextnodename.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /nodetextnodetype.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /nodetextnodevalue.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodevalue01.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /nodevalue02.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /nodevalue03.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /nodevalue04.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /nodevalue05.xml/1.3/Fri Apr 3 02:48:04 2009// |
| /nodevalue06.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /nodevalue07.xml/1.5/Fri Apr 3 02:48:04 2009// |
| /nodevalue08.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /nodevalue09.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /notationgetnotationname.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /notationgetpublicid.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /notationgetpublicidnull.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /notationgetsystemid.xml/1.11/Fri Apr 3 02:48:03 2009// |
| /notationgetsystemidnull.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /processinginstructiongetdata.xml/1.8/Fri Apr 3 02:48:04 2009// |
| /processinginstructiongettarget.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /processinginstructionsetdatanomodificationallowederr.xml/1.12/Fri Apr 3 02:48:04 2009// |
| /processinginstructionsetdatanomodificationallowederrEE.xml/1.10/Fri Apr 3 02:48:04 2009// |
| /textindexsizeerrnegativeoffset.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /textindexsizeerroffsetoutofbounds.xml/1.6/Fri Apr 3 02:48:04 2009// |
| /textparseintolistofelements.xml/1.11/Fri Apr 3 02:48:03 2009// |
| /textsplittextfour.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /textsplittextnomodificationallowederr.xml/1.11/Fri Apr 3 02:48:04 2009// |
| /textsplittextnomodificationallowederrEE.xml/1.9/Fri Apr 3 02:48:04 2009// |
| /textsplittextone.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /textsplittextthree.xml/1.7/Fri Apr 3 02:48:04 2009// |
| /textsplittexttwo.xml/1.7/Fri Apr 3 02:48:03 2009// |
| /textwithnomarkup.xml/1.8/Fri Apr 3 02:48:03 2009// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level1/core |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/CVS/Template |
|---|
| --- test/testcases/tests/level1/core/alltests.xml (nonexistent) |
| +++ test/testcases/tests/level1/core/alltests.xml (revision 4364) |
| @@ -0,0 +1,550 @@ |
| +<?xml version="1.0" encoding="UTF-8"?> |
| +<!-- |
| +Copyright (c) 2001-2004 World Wide Web Consortium, |
| +(Massachusetts Institute of Technology, Institut National de |
| +Recherche en Informatique et en Automatique, Keio University). All |
| +Rights Reserved. This program is distributed under the W3C's Software |
| +Intellectual Property License. This program is distributed in the |
| +hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| +PURPOSE. |
| +See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| +--><!DOCTYPE suite SYSTEM "dom1.dtd"> |
| + |
| +<suite xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="alltests"> |
| +<metadata> |
| +<title>DOM Level 1 Core Test Suite</title> |
| +<creator>DOM Test Suite Project</creator> |
| +</metadata> |
| +<suite.member href="attrcreatedocumentfragment.xml"/> |
| +<suite.member href="attrcreatetextnode.xml"/> |
| +<suite.member href="attrcreatetextnode2.xml"/> |
| +<suite.member href="attrdefaultvalue.xml"/> |
| +<suite.member href="attreffectivevalue.xml"/> |
| +<suite.member href="attrentityreplacement.xml"/> |
| +<suite.member href="attrname.xml"/> |
| +<suite.member href="attrnextsiblingnull.xml"/> |
| +<suite.member href="attrnotspecifiedvalue.xml"/> |
| +<suite.member href="attrparentnodenull.xml"/> |
| +<suite.member href="attrprevioussiblingnull.xml"/> |
| +<suite.member href="attrsetvaluenomodificationallowederr.xml"/> |
| +<suite.member href="attrsetvaluenomodificationallowederrEE.xml"/> |
| +<suite.member href="attrspecifiedvalue.xml"/> |
| +<suite.member href="attrspecifiedvaluechanged.xml"/> |
| +<suite.member href="attrspecifiedvalueremove.xml"/> |
| +<suite.member href="cdatasectiongetdata.xml"/> |
| +<suite.member href="cdatasectionnormalize.xml"/> |
| +<suite.member href="characterdataappenddata.xml"/> |
| +<suite.member href="characterdataappenddatagetdata.xml"/> |
| +<suite.member href="characterdataappenddatanomodificationallowederr.xml"/> |
| +<suite.member href="characterdataappenddatanomodificationallowederrEE.xml"/> |
| +<suite.member href="characterdatadeletedatabegining.xml"/> |
| +<suite.member href="characterdatadeletedataend.xml"/> |
| +<suite.member href="characterdatadeletedataexceedslength.xml"/> |
| +<suite.member href="characterdatadeletedatagetlengthanddata.xml"/> |
| +<suite.member href="characterdatadeletedatamiddle.xml"/> |
| +<suite.member href="characterdatadeletedatanomodificationallowederr.xml"/> |
| +<suite.member href="characterdatadeletedatanomodificationallowederrEE.xml"/> |
| +<suite.member href="characterdatagetdata.xml"/> |
| +<suite.member href="characterdatagetlength.xml"/> |
| +<suite.member href="characterdataindexsizeerrdeletedatacountnegative.xml"/> |
| +<suite.member href="characterdataindexsizeerrdeletedataoffsetgreater.xml"/> |
| +<suite.member href="characterdataindexsizeerrdeletedataoffsetnegative.xml"/> |
| +<suite.member href="characterdataindexsizeerrinsertdataoffsetgreater.xml"/> |
| +<suite.member href="characterdataindexsizeerrinsertdataoffsetnegative.xml"/> |
| +<suite.member href="characterdataindexsizeerrreplacedatacountnegative.xml"/> |
| +<suite.member href="characterdataindexsizeerrreplacedataoffsetgreater.xml"/> |
| +<suite.member href="characterdataindexsizeerrreplacedataoffsetnegative.xml"/> |
| +<suite.member href="characterdataindexsizeerrsubstringcountnegative.xml"/> |
| +<suite.member href="characterdataindexsizeerrsubstringnegativeoffset.xml"/> |
| +<suite.member href="characterdataindexsizeerrsubstringoffsetgreater.xml"/> |
| +<suite.member href="characterdatainsertdatabeginning.xml"/> |
| +<suite.member href="characterdatainsertdataend.xml"/> |
| +<suite.member href="characterdatainsertdatamiddle.xml"/> |
| +<suite.member href="characterdatainsertdatanomodificationallowederr.xml"/> |
| +<suite.member href="characterdatainsertdatanomodificationallowederrEE.xml"/> |
| +<suite.member href="characterdatareplacedatabegining.xml"/> |
| +<suite.member href="characterdatareplacedataend.xml"/> |
| +<suite.member href="characterdatareplacedataexceedslengthofarg.xml"/> |
| +<suite.member href="characterdatareplacedataexceedslengthofdata.xml"/> |
| +<suite.member href="characterdatareplacedatamiddle.xml"/> |
| +<suite.member href="characterdatareplacedatanomodificationallowederr.xml"/> |
| +<suite.member href="characterdatareplacedatanomodificationallowederrEE.xml"/> |
| +<suite.member href="characterdatasetdatanomodificationallowederr.xml"/> |
| +<suite.member href="characterdatasetdatanomodificationallowederrEE.xml"/> |
| +<suite.member href="characterdatasetnodevalue.xml"/> |
| +<suite.member href="characterdatasubstringexceedsvalue.xml"/> |
| +<suite.member href="characterdatasubstringvalue.xml"/> |
| +<suite.member href="commentgetcomment.xml"/> |
| +<suite.member href="documentcreateattribute.xml"/> |
| +<suite.member href="documentcreatecdatasection.xml"/> |
| +<suite.member href="documentcreatecomment.xml"/> |
| +<suite.member href="documentcreatedocumentfragment.xml"/> |
| +<suite.member href="documentcreateelement.xml"/> |
| +<suite.member href="documentcreateelementcasesensitive.xml"/> |
| +<suite.member href="documentcreateelementdefaultattr.xml"/> |
| +<suite.member href="documentcreateentityreference.xml"/> |
| +<suite.member href="documentcreateentityreferenceknown.xml"/> |
| +<suite.member href="documentcreateprocessinginstruction.xml"/> |
| +<suite.member href="documentcreatetextnode.xml"/> |
| +<suite.member href="documentgetdoctype.xml"/> |
| +<suite.member href="documentgetdoctypenodtd.xml"/> |
| +<suite.member href="documentgetelementsbytagnamelength.xml"/> |
| +<suite.member href="documentgetelementsbytagnametotallength.xml"/> |
| +<suite.member href="documentgetelementsbytagnamevalue.xml"/> |
| +<suite.member href="documentgetimplementation.xml"/> |
| +<suite.member href="documentgetrootnode.xml"/> |
| +<suite.member href="documentinvalidcharacterexceptioncreateattribute.xml"/> |
| +<suite.member href="documentinvalidcharacterexceptioncreateelement.xml"/> |
| +<suite.member href="documentinvalidcharacterexceptioncreateentref.xml"/> |
| +<suite.member href="documentinvalidcharacterexceptioncreateentref1.xml"/> |
| +<suite.member href="documentinvalidcharacterexceptioncreatepi.xml"/> |
| +<suite.member href="documentinvalidcharacterexceptioncreatepi1.xml"/> |
| +<suite.member href="documenttypegetdoctype.xml"/> |
| +<suite.member href="documenttypegetentities.xml"/> |
| +<suite.member href="documenttypegetentitieslength.xml"/> |
| +<suite.member href="documenttypegetentitiestype.xml"/> |
| +<suite.member href="documenttypegetnotations.xml"/> |
| +<suite.member href="documenttypegetnotationstype.xml"/> |
| +<suite.member href="domimplementationfeaturenoversion.xml"/> |
| +<suite.member href="domimplementationfeaturenull.xml"/> |
| +<suite.member href="domimplementationfeaturexml.xml"/> |
| +<suite.member href="elementaddnewattribute.xml"/> |
| +<suite.member href="elementassociatedattribute.xml"/> |
| +<suite.member href="elementchangeattributevalue.xml"/> |
| +<suite.member href="elementcreatenewattribute.xml"/> |
| +<suite.member href="elementgetattributenode.xml"/> |
| +<suite.member href="elementgetattributenodenull.xml"/> |
| +<suite.member href="elementgetelementempty.xml"/> |
| +<suite.member href="elementgetelementsbytagname.xml"/> |
| +<suite.member href="elementgetelementsbytagnameaccessnodelist.xml"/> |
| +<suite.member href="elementgetelementsbytagnamenomatch.xml"/> |
| +<suite.member href="elementgetelementsbytagnamespecialvalue.xml"/> |
| +<suite.member href="elementgettagname.xml"/> |
| +<suite.member href="elementinuseattributeerr.xml"/> |
| +<suite.member href="elementinvalidcharacterexception.xml"/> |
| +<suite.member href="elementnormalize.xml"/> |
| +<suite.member href="elementnotfounderr.xml"/> |
| +<suite.member href="elementremoveattribute.xml"/> |
| +<suite.member href="elementremoveattributeaftercreate.xml"/> |
| +<suite.member href="elementremoveattributenode.xml"/> |
| +<suite.member href="elementremoveattributenodenomodificationallowederr.xml"/> |
| +<suite.member href="elementremoveattributenodenomodificationallowederrEE.xml"/> |
| +<suite.member href="elementremoveattributenomodificationallowederr.xml"/> |
| +<suite.member href="elementremoveattributenomodificationallowederrEE.xml"/> |
| +<suite.member href="elementremoveattributerestoredefaultvalue.xml"/> |
| +<suite.member href="elementreplaceattributewithself.xml"/> |
| +<suite.member href="elementreplaceexistingattribute.xml"/> |
| +<suite.member href="elementreplaceexistingattributegevalue.xml"/> |
| +<suite.member href="elementretrieveallattributes.xml"/> |
| +<suite.member href="elementretrieveattrvalue.xml"/> |
| +<suite.member href="elementretrievetagname.xml"/> |
| +<suite.member href="elementsetattributenodenomodificationallowederr.xml"/> |
| +<suite.member href="elementsetattributenodenomodificationallowederrEE.xml"/> |
| +<suite.member href="elementsetattributenodenull.xml"/> |
| +<suite.member href="elementsetattributenomodificationallowederr.xml"/> |
| +<suite.member href="elementsetattributenomodificationallowederrEE.xml"/> |
| +<suite.member href="elementwrongdocumenterr.xml"/> |
| +<suite.member href="entitygetentityname.xml"/> |
| +<suite.member href="entitygetpublicid.xml"/> |
| +<suite.member href="entitygetpublicidnull.xml"/> |
| +<suite.member href="namednodemapchildnoderange.xml"/> |
| +<suite.member href="namednodemapgetnameditem.xml"/> |
| +<suite.member href="namednodemapinuseattributeerr.xml"/> |
| +<suite.member href="namednodemapnotfounderr.xml"/> |
| +<suite.member href="namednodemapnumberofnodes.xml"/> |
| +<suite.member href="namednodemapremovenameditem.xml"/> |
| +<suite.member href="namednodemapremovenameditemgetvalue.xml"/> |
| +<suite.member href="namednodemapremovenameditemreturnnodevalue.xml"/> |
| +<suite.member href="namednodemapreturnattrnode.xml"/> |
| +<suite.member href="namednodemapreturnfirstitem.xml"/> |
| +<suite.member href="namednodemapreturnlastitem.xml"/> |
| +<suite.member href="namednodemapreturnnull.xml"/> |
| +<suite.member href="namednodemapsetnameditem.xml"/> |
| +<suite.member href="namednodemapsetnameditemreturnvalue.xml"/> |
| +<suite.member href="namednodemapsetnameditemthatexists.xml"/> |
| +<suite.member href="namednodemapsetnameditemwithnewvalue.xml"/> |
| +<suite.member href="namednodemapwrongdocumenterr.xml"/> |
| +<suite.member href="nodeappendchild.xml"/> |
| +<suite.member href="nodeappendchildchildexists.xml"/> |
| +<suite.member href="nodeappendchilddocfragment.xml"/> |
| +<suite.member href="nodeappendchildgetnodename.xml"/> |
| +<suite.member href="nodeappendchildinvalidnodetype.xml"/> |
| +<suite.member href="nodeappendchildnewchilddiffdocument.xml"/> |
| +<suite.member href="nodeappendchildnodeancestor.xml"/> |
| +<suite.member href="nodeappendchildnomodificationallowederr.xml"/> |
| +<suite.member href="nodeappendchildnomodificationallowederrEE.xml"/> |
| +<suite.member href="nodeattributenodeattribute.xml"/> |
| +<suite.member href="nodeattributenodename.xml"/> |
| +<suite.member href="nodeattributenodetype.xml"/> |
| +<suite.member href="nodeattributenodevalue.xml"/> |
| +<suite.member href="nodecdatasectionnodeattribute.xml"/> |
| +<suite.member href="nodecdatasectionnodename.xml"/> |
| +<suite.member href="nodecdatasectionnodetype.xml"/> |
| +<suite.member href="nodecdatasectionnodevalue.xml"/> |
| +<suite.member href="nodechildnodes.xml"/> |
| +<suite.member href="nodechildnodesappendchild.xml"/> |
| +<suite.member href="nodechildnodesempty.xml"/> |
| +<suite.member href="nodecloneattributescopied.xml"/> |
| +<suite.member href="nodeclonefalsenocopytext.xml"/> |
| +<suite.member href="nodeclonegetparentnull.xml"/> |
| +<suite.member href="nodeclonenodefalse.xml"/> |
| +<suite.member href="nodeclonenodetrue.xml"/> |
| +<suite.member href="nodeclonetruecopytext.xml"/> |
| +<suite.member href="nodecommentnodeattributes.xml"/> |
| +<suite.member href="nodecommentnodename.xml"/> |
| +<suite.member href="nodecommentnodetype.xml"/> |
| +<suite.member href="nodecommentnodevalue.xml"/> |
| +<suite.member href="nodedocumentfragmentnodename.xml"/> |
| +<suite.member href="nodedocumentfragmentnodetype.xml"/> |
| +<suite.member href="nodedocumentfragmentnodevalue.xml"/> |
| +<suite.member href="nodedocumentnodeattribute.xml"/> |
| +<suite.member href="nodedocumentnodename.xml"/> |
| +<suite.member href="nodedocumentnodetype.xml"/> |
| +<suite.member href="nodedocumentnodevalue.xml"/> |
| +<suite.member href="nodedocumenttypenodename.xml"/> |
| +<suite.member href="nodedocumenttypenodetype.xml"/> |
| +<suite.member href="nodedocumenttypenodevalue.xml"/> |
| +<suite.member href="nodeelementnodeattributes.xml"/> |
| +<suite.member href="nodeelementnodename.xml"/> |
| +<suite.member href="nodeelementnodetype.xml"/> |
| +<suite.member href="nodeelementnodevalue.xml"/> |
| +<suite.member href="nodeentitynodeattributes.xml"/> |
| +<suite.member href="nodeentitynodename.xml"/> |
| +<suite.member href="nodeentitynodetype.xml"/> |
| +<suite.member href="nodeentitynodevalue.xml"/> |
| +<suite.member href="nodeentitysetnodevalue.xml"/> |
| +<suite.member href="nodeentityreferencenodeattributes.xml"/> |
| +<suite.member href="nodeentityreferencenodename.xml"/> |
| +<suite.member href="nodeentityreferencenodetype.xml"/> |
| +<suite.member href="nodeentityreferencenodevalue.xml"/> |
| +<suite.member href="nodegetfirstchild.xml"/> |
| +<suite.member href="nodegetfirstchildnull.xml"/> |
| +<suite.member href="nodegetlastchild.xml"/> |
| +<suite.member href="nodegetlastchildnull.xml"/> |
| +<suite.member href="nodegetnextsibling.xml"/> |
| +<suite.member href="nodegetnextsiblingnull.xml"/> |
| +<suite.member href="nodegetownerdocument.xml"/> |
| +<suite.member href="nodegetownerdocumentnull.xml"/> |
| +<suite.member href="nodegetprevioussibling.xml"/> |
| +<suite.member href="nodegetprevioussiblingnull.xml"/> |
| +<suite.member href="nodehaschildnodes.xml"/> |
| +<suite.member href="nodehaschildnodesfalse.xml"/> |
| +<suite.member href="nodeinsertbefore.xml"/> |
| +<suite.member href="nodeinsertbeforedocfragment.xml"/> |
| +<suite.member href="nodeinsertbeforeinvalidnodetype.xml"/> |
| +<suite.member href="nodeinsertbeforenewchilddiffdocument.xml"/> |
| +<suite.member href="nodeinsertbeforenewchildexists.xml"/> |
| +<suite.member href="nodeinsertbeforenodeancestor.xml"/> |
| +<suite.member href="nodeinsertbeforenodename.xml"/> |
| +<suite.member href="nodeinsertbeforenomodificationallowederr.xml"/> |
| +<suite.member href="nodeinsertbeforenomodificationallowederrEE.xml"/> |
| +<suite.member href="nodeinsertbeforerefchildnonexistent.xml"/> |
| +<suite.member href="nodeinsertbeforerefchildnull.xml"/> |
| +<suite.member href="nodelistindexequalzero.xml"/> |
| +<suite.member href="nodelistindexgetlength.xml"/> |
| +<suite.member href="nodelistindexgetlengthofemptylist.xml"/> |
| +<suite.member href="nodelistindexnotzero.xml"/> |
| +<suite.member href="nodelistreturnfirstitem.xml"/> |
| +<suite.member href="nodelistreturnlastitem.xml"/> |
| +<suite.member href="nodelisttraverselist.xml"/> |
| +<suite.member href="nodenotationnodeattributes.xml"/> |
| +<suite.member href="nodenotationnodename.xml"/> |
| +<suite.member href="nodenotationnodetype.xml"/> |
| +<suite.member href="nodenotationnodevalue.xml"/> |
| +<suite.member href="nodeparentnode.xml"/> |
| +<suite.member href="nodeparentnodenull.xml"/> |
| +<suite.member href="nodeprocessinginstructionnodeattributes.xml"/> |
| +<suite.member href="nodeprocessinginstructionnodename.xml"/> |
| +<suite.member href="nodeprocessinginstructionnodetype.xml"/> |
| +<suite.member href="nodeprocessinginstructionnodevalue.xml"/> |
| +<suite.member href="nodeprocessinginstructionsetnodevalue.xml"/> |
| +<suite.member href="noderemovechild.xml"/> |
| +<suite.member href="noderemovechildgetnodename.xml"/> |
| +<suite.member href="noderemovechildnode.xml"/> |
| +<suite.member href="noderemovechildnomodificationallowederr.xml"/> |
| +<suite.member href="noderemovechildnomodificationallowederrEE.xml"/> |
| +<suite.member href="noderemovechildoldchildnonexistent.xml"/> |
| +<suite.member href="nodereplacechild.xml"/> |
| +<suite.member href="nodereplacechildinvalidnodetype.xml"/> |
| +<suite.member href="nodereplacechildnewchilddiffdocument.xml"/> |
| +<suite.member href="nodereplacechildnewchildexists.xml"/> |
| +<suite.member href="nodereplacechildnodeancestor.xml"/> |
| +<suite.member href="nodereplacechildnodename.xml"/> |
| +<suite.member href="nodereplacechildnomodificationallowederr.xml"/> |
| +<suite.member href="nodereplacechildnomodificationallowederrEE.xml"/> |
| +<suite.member href="nodereplacechildoldchildnonexistent.xml"/> |
| +<suite.member href="nodesetnodevaluenomodificationallowederr.xml"/> |
| +<suite.member href="nodesetnodevaluenomodificationallowederrEE.xml"/> |
| +<suite.member href="nodetextnodeattribute.xml"/> |
| +<suite.member href="nodetextnodename.xml"/> |
| +<suite.member href="nodetextnodetype.xml"/> |
| +<suite.member href="nodetextnodevalue.xml"/> |
| +<suite.member href="notationgetnotationname.xml"/> |
| +<suite.member href="notationgetpublicid.xml"/> |
| +<suite.member href="notationgetpublicidnull.xml"/> |
| +<suite.member href="notationgetsystemid.xml"/> |
| +<suite.member href="notationgetsystemidnull.xml"/> |
| +<suite.member href="processinginstructiongetdata.xml"/> |
| +<suite.member href="processinginstructiongettarget.xml"/> |
| +<suite.member href="processinginstructionsetdatanomodificationallowederr.xml"/> |
| +<suite.member href="processinginstructionsetdatanomodificationallowederrEE.xml"/> |
| +<suite.member href="textindexsizeerrnegativeoffset.xml"/> |
| +<suite.member href="textindexsizeerroffsetoutofbounds.xml"/> |
| +<suite.member href="textparseintolistofelements.xml"/> |
| +<suite.member href="textsplittextfour.xml"/> |
| +<suite.member href="textsplittextnomodificationallowederr.xml"/> |
| +<suite.member href="textsplittextnomodificationallowederrEE.xml"/> |
| +<suite.member href="textsplittextone.xml"/> |
| +<suite.member href="textsplittextthree.xml"/> |
| +<suite.member href="textsplittexttwo.xml"/> |
| +<suite.member href="textwithnomarkup.xml"/> |
| +<suite.member href="nodevalue01.xml"/> |
| +<suite.member href="nodevalue02.xml"/> |
| +<suite.member href="nodevalue03.xml"/> |
| +<suite.member href="nodevalue04.xml"/> |
| +<suite.member href="nodevalue05.xml"/> |
| +<suite.member href="nodevalue06.xml"/> |
| +<suite.member href="nodevalue07.xml"/> |
| +<suite.member href="nodevalue08.xml"/> |
| +<suite.member href="nodevalue09.xml"/> |
| +<!-- HTML compatible equivalents of the previous tests that |
| + only used Fundamental interfaces --> |
| +<suite.member href="hc_attrcreatedocumentfragment.xml"/> |
| +<suite.member href="hc_attrcreatetextnode.xml"/> |
| +<suite.member href="hc_attrcreatetextnode2.xml"/> |
| +<suite.member href="hc_attreffectivevalue.xml"/> |
| +<suite.member href="hc_attrname.xml"/> |
| +<suite.member href="hc_attrnextsiblingnull.xml"/> |
| +<suite.member href="hc_attrparentnodenull.xml"/> |
| +<suite.member href="hc_attrprevioussiblingnull.xml"/> |
| +<suite.member href="hc_attrspecifiedvalue.xml"/> |
| +<suite.member href="hc_attrspecifiedvaluechanged.xml"/> |
| +<suite.member href="hc_characterdataappenddata.xml"/> |
| +<suite.member href="hc_characterdataappenddatagetdata.xml"/> |
| +<suite.member href="hc_characterdatadeletedatabegining.xml"/> |
| +<suite.member href="hc_characterdatadeletedataend.xml"/> |
| +<suite.member href="hc_characterdatadeletedataexceedslength.xml"/> |
| +<suite.member href="hc_characterdatadeletedatagetlengthanddata.xml"/> |
| +<suite.member href="hc_characterdatadeletedatamiddle.xml"/> |
| +<suite.member href="hc_characterdatagetdata.xml"/> |
| +<suite.member href="hc_characterdatagetlength.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrdeletedatacountnegative.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrdeletedataoffsetgreater.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrdeletedataoffsetnegative.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrinsertdataoffsetgreater.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrinsertdataoffsetnegative.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrreplacedatacountnegative.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrreplacedataoffsetgreater.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrreplacedataoffsetnegative.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrsubstringcountnegative.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrsubstringnegativeoffset.xml"/> |
| +<suite.member href="hc_characterdataindexsizeerrsubstringoffsetgreater.xml"/> |
| +<suite.member href="hc_characterdatainsertdatabeginning.xml"/> |
| +<suite.member href="hc_characterdatainsertdataend.xml"/> |
| +<suite.member href="hc_characterdatainsertdatamiddle.xml"/> |
| +<suite.member href="hc_characterdatareplacedatabegining.xml"/> |
| +<suite.member href="hc_characterdatareplacedataend.xml"/> |
| +<suite.member href="hc_characterdatareplacedataexceedslengthofarg.xml"/> |
| +<suite.member href="hc_characterdatareplacedataexceedslengthofdata.xml"/> |
| +<suite.member href="hc_characterdatareplacedatamiddle.xml"/> |
| +<suite.member href="hc_characterdatasetnodevalue.xml"/> |
| +<suite.member href="hc_characterdatasubstringexceedsvalue.xml"/> |
| +<suite.member href="hc_characterdatasubstringvalue.xml"/> |
| +<suite.member href="hc_commentgetcomment.xml"/> |
| +<suite.member href="hc_documentcreateattribute.xml"/> |
| +<suite.member href="hc_documentcreatecomment.xml"/> |
| +<suite.member href="hc_documentcreatedocumentfragment.xml"/> |
| +<suite.member href="hc_documentcreateelement.xml"/> |
| +<suite.member href="hc_documentcreateelementcasesensitive.xml"/> |
| +<suite.member href="hc_documentcreatetextnode.xml"/> |
| +<suite.member href="hc_documentgetdoctype.xml"/> |
| +<suite.member href="hc_documentgetelementsbytagnamelength.xml"/> |
| +<suite.member href="hc_documentgetelementsbytagnametotallength.xml"/> |
| +<suite.member href="hc_documentgetelementsbytagnamevalue.xml"/> |
| +<suite.member href="hc_documentgetimplementation.xml"/> |
| +<suite.member href="hc_documentgetrootnode.xml"/> |
| +<suite.member href="hc_documentinvalidcharacterexceptioncreateattribute.xml"/> |
| +<suite.member href="hc_documentinvalidcharacterexceptioncreateattribute1.xml"/> |
| +<suite.member href="hc_documentinvalidcharacterexceptioncreateelement.xml"/> |
| +<suite.member href="hc_documentinvalidcharacterexceptioncreateelement1.xml"/> |
| +<suite.member href="hc_domimplementationfeaturenoversion.xml"/> |
| +<suite.member href="hc_domimplementationfeaturenull.xml"/> |
| +<suite.member href="hc_domimplementationfeaturexml.xml"/> |
| +<suite.member href="hc_elementaddnewattribute.xml"/> |
| +<suite.member href="hc_elementassociatedattribute.xml"/> |
| +<suite.member href="hc_elementchangeattributevalue.xml"/> |
| +<suite.member href="hc_elementcreatenewattribute.xml"/> |
| +<suite.member href="hc_elementgetattributenode.xml"/> |
| +<suite.member href="hc_elementgetattributenodenull.xml"/> |
| +<suite.member href="hc_elementgetelementempty.xml"/> |
| +<suite.member href="hc_elementgetelementsbytagname.xml"/> |
| +<suite.member href="hc_elementgetelementsbytagnameaccessnodelist.xml"/> |
| +<suite.member href="hc_elementgetelementsbytagnamenomatch.xml"/> |
| +<suite.member href="hc_elementgetelementsbytagnamespecialvalue.xml"/> |
| +<suite.member href="hc_elementgettagname.xml"/> |
| +<suite.member href="hc_elementinuseattributeerr.xml"/> |
| +<suite.member href="hc_elementinvalidcharacterexception.xml"/> |
| +<suite.member href="hc_elementinvalidcharacterexception1.xml"/> |
| +<suite.member href="hc_elementnormalize.xml"/> |
| +<suite.member href="hc_elementnormalize2.xml"/> |
| +<suite.member href="hc_elementnotfounderr.xml"/> |
| +<suite.member href="hc_elementremoveattribute.xml"/> |
| +<suite.member href="hc_elementremoveattributeaftercreate.xml"/> |
| +<suite.member href="hc_elementremoveattributenode.xml"/> |
| +<suite.member href="hc_elementreplaceattributewithself.xml"/> |
| +<suite.member href="hc_elementreplaceexistingattribute.xml"/> |
| +<suite.member href="hc_elementreplaceexistingattributegevalue.xml"/> |
| +<suite.member href="hc_elementretrieveallattributes.xml"/> |
| +<suite.member href="hc_elementretrieveattrvalue.xml"/> |
| +<suite.member href="hc_elementretrievetagname.xml"/> |
| +<suite.member href="hc_elementsetattributenodenull.xml"/> |
| +<suite.member href="hc_elementwrongdocumenterr.xml"/> |
| +<suite.member href="hc_entitiesremovenameditem1.xml"/> |
| +<suite.member href="hc_entitiessetnameditem1.xml"/> |
| +<suite.member href="hc_namednodemapchildnoderange.xml"/> |
| +<suite.member href="hc_namednodemapgetnameditem.xml"/> |
| +<suite.member href="hc_namednodemapinuseattributeerr.xml"/> |
| +<suite.member href="hc_namednodemapnotfounderr.xml"/> |
| +<suite.member href="hc_namednodemapnumberofnodes.xml"/> |
| +<suite.member href="hc_namednodemapremovenameditem.xml"/> |
| +<suite.member href="hc_namednodemapreturnattrnode.xml"/> |
| +<suite.member href="hc_namednodemapreturnfirstitem.xml"/> |
| +<suite.member href="hc_namednodemapreturnlastitem.xml"/> |
| +<suite.member href="hc_namednodemapreturnnull.xml"/> |
| +<suite.member href="hc_namednodemapsetnameditem.xml"/> |
| +<suite.member href="hc_namednodemapsetnameditemreturnvalue.xml"/> |
| +<suite.member href="hc_namednodemapsetnameditemthatexists.xml"/> |
| +<suite.member href="hc_namednodemapsetnameditemwithnewvalue.xml"/> |
| +<suite.member href="hc_namednodemapwrongdocumenterr.xml"/> |
| +<suite.member href="hc_nodeappendchild.xml"/> |
| +<suite.member href="hc_nodeappendchildchildexists.xml"/> |
| +<suite.member href="hc_nodeappendchilddocfragment.xml"/> |
| +<suite.member href="hc_nodeappendchildgetnodename.xml"/> |
| +<suite.member href="hc_nodeappendchildinvalidnodetype.xml"/> |
| +<suite.member href="hc_nodeappendchildnewchilddiffdocument.xml"/> |
| +<suite.member href="hc_nodeappendchildnodeancestor.xml"/> |
| +<suite.member href="hc_nodeattributenodeattribute.xml"/> |
| +<suite.member href="hc_nodeattributenodename.xml"/> |
| +<suite.member href="hc_nodeattributenodetype.xml"/> |
| +<suite.member href="hc_nodeattributenodevalue.xml"/> |
| +<suite.member href="hc_nodechildnodes.xml"/> |
| +<suite.member href="hc_nodechildnodesappendchild.xml"/> |
| +<suite.member href="hc_nodechildnodesempty.xml"/> |
| +<suite.member href="hc_nodecloneattributescopied.xml"/> |
| +<suite.member href="hc_nodeclonefalsenocopytext.xml"/> |
| +<suite.member href="hc_nodeclonegetparentnull.xml"/> |
| +<suite.member href="hc_nodeclonenodefalse.xml"/> |
| +<suite.member href="hc_nodeclonenodetrue.xml"/> |
| +<suite.member href="hc_nodeclonetruecopytext.xml"/> |
| +<suite.member href="hc_nodecommentnodeattributes.xml"/> |
| +<suite.member href="hc_nodecommentnodename.xml"/> |
| +<suite.member href="hc_nodecommentnodetype.xml"/> |
| +<suite.member href="hc_nodecommentnodevalue.xml"/> |
| +<suite.member href="hc_nodedocumentfragmentnodename.xml"/> |
| +<suite.member href="hc_nodedocumentfragmentnodetype.xml"/> |
| +<suite.member href="hc_nodedocumentfragmentnodevalue.xml"/> |
| +<suite.member href="hc_nodedocumentnodeattribute.xml"/> |
| +<suite.member href="hc_nodedocumentnodename.xml"/> |
| +<suite.member href="hc_nodedocumentnodetype.xml"/> |
| +<suite.member href="hc_nodedocumentnodevalue.xml"/> |
| +<suite.member href="hc_nodeelementnodeattributes.xml"/> |
| +<suite.member href="hc_nodeelementnodename.xml"/> |
| +<suite.member href="hc_nodeelementnodetype.xml"/> |
| +<suite.member href="hc_nodeelementnodevalue.xml"/> |
| +<suite.member href="hc_nodegetfirstchild.xml"/> |
| +<suite.member href="hc_nodegetfirstchildnull.xml"/> |
| +<suite.member href="hc_nodegetlastchild.xml"/> |
| +<suite.member href="hc_nodegetlastchildnull.xml"/> |
| +<suite.member href="hc_nodegetnextsibling.xml"/> |
| +<suite.member href="hc_nodegetnextsiblingnull.xml"/> |
| +<suite.member href="hc_nodegetownerdocument.xml"/> |
| +<suite.member href="hc_nodegetownerdocumentnull.xml"/> |
| +<suite.member href="hc_nodegetprevioussibling.xml"/> |
| +<suite.member href="hc_nodegetprevioussiblingnull.xml"/> |
| +<suite.member href="hc_nodehaschildnodes.xml"/> |
| +<suite.member href="hc_nodehaschildnodesfalse.xml"/> |
| +<suite.member href="hc_nodeinsertbefore.xml"/> |
| +<suite.member href="hc_nodeinsertbeforedocfragment.xml"/> |
| +<suite.member href="hc_nodeinsertbeforeinvalidnodetype.xml"/> |
| +<suite.member href="hc_nodeinsertbeforenewchilddiffdocument.xml"/> |
| +<suite.member href="hc_nodeinsertbeforenewchildexists.xml"/> |
| +<suite.member href="hc_nodeinsertbeforenodeancestor.xml"/> |
| +<suite.member href="hc_nodeinsertbeforenodename.xml"/> |
| +<suite.member href="hc_nodeinsertbeforerefchildnonexistent.xml"/> |
| +<suite.member href="hc_nodeinsertbeforerefchildnull.xml"/> |
| +<suite.member href="hc_nodelistindexequalzero.xml"/> |
| +<suite.member href="hc_nodelistindexgetlength.xml"/> |
| +<suite.member href="hc_nodelistindexgetlengthofemptylist.xml"/> |
| +<suite.member href="hc_nodelistindexnotzero.xml"/> |
| +<suite.member href="hc_nodelistreturnfirstitem.xml"/> |
| +<suite.member href="hc_nodelistreturnlastitem.xml"/> |
| +<suite.member href="hc_nodelisttraverselist.xml"/> |
| +<suite.member href="hc_nodeparentnode.xml"/> |
| +<suite.member href="hc_nodeparentnodenull.xml"/> |
| +<suite.member href="hc_noderemovechild.xml"/> |
| +<suite.member href="hc_noderemovechildgetnodename.xml"/> |
| +<suite.member href="hc_noderemovechildnode.xml"/> |
| +<suite.member href="hc_noderemovechildoldchildnonexistent.xml"/> |
| +<suite.member href="hc_nodereplacechild.xml"/> |
| +<suite.member href="hc_nodereplacechildinvalidnodetype.xml"/> |
| +<suite.member href="hc_nodereplacechildnewchilddiffdocument.xml"/> |
| +<suite.member href="hc_nodereplacechildnewchildexists.xml"/> |
| +<suite.member href="hc_nodereplacechildnodeancestor.xml"/> |
| +<suite.member href="hc_nodereplacechildnodename.xml"/> |
| +<suite.member href="hc_nodereplacechildoldchildnonexistent.xml"/> |
| +<suite.member href="hc_nodetextnodeattribute.xml"/> |
| +<suite.member href="hc_nodetextnodename.xml"/> |
| +<suite.member href="hc_nodetextnodetype.xml"/> |
| +<suite.member href="hc_nodetextnodevalue.xml"/> |
| +<suite.member href="hc_nodevalue01.xml"/> |
| +<suite.member href="hc_nodevalue02.xml"/> |
| +<suite.member href="hc_nodevalue03.xml"/> |
| +<suite.member href="hc_nodevalue04.xml"/> |
| +<suite.member href="hc_nodevalue05.xml"/> |
| +<suite.member href="hc_nodevalue06.xml"/> |
| +<suite.member href="hc_nodevalue07.xml"/> |
| +<suite.member href="hc_nodevalue08.xml"/> |
| +<suite.member href="hc_notationsremovenameditem1.xml"/> |
| +<suite.member href="hc_notationssetnameditem1.xml"/> |
| +<suite.member href="hc_textindexsizeerrnegativeoffset.xml"/> |
| +<suite.member href="hc_textindexsizeerroffsetoutofbounds.xml"/> |
| +<suite.member href="hc_textparseintolistofelements.xml"/> |
| +<suite.member href="hc_textsplittextfour.xml"/> |
| +<suite.member href="hc_textsplittextone.xml"/> |
| +<suite.member href="hc_textsplittextthree.xml"/> |
| +<suite.member href="hc_textsplittexttwo.xml"/> |
| +<suite.member href="hc_textwithnomarkup.xml"/> |
| + |
| +<suite.member href="hc_attrappendchild1.xml"/> |
| +<suite.member href="hc_attrappendchild2.xml"/> |
| +<suite.member href="hc_attrappendchild3.xml"/> |
| +<suite.member href="hc_attrappendchild4.xml"/> |
| +<suite.member href="hc_attrappendchild5.xml"/> |
| +<suite.member href="hc_attrappendchild6.xml"/> |
| +<suite.member href="hc_attrchildnodes1.xml"/> |
| +<suite.member href="hc_attrchildnodes2.xml"/> |
| +<suite.member href="hc_attrclonenode1.xml"/> |
| +<suite.member href="hc_attrfirstchild.xml"/> |
| +<suite.member href="hc_attrgetvalue1.xml"/> |
| +<suite.member href="hc_attrgetvalue2.xml"/> |
| +<suite.member href="hc_attrhaschildnodes.xml"/> |
| +<suite.member href="hc_attrinsertbefore1.xml"/> |
| +<suite.member href="hc_attrinsertbefore2.xml"/> |
| +<suite.member href="hc_attrinsertbefore3.xml"/> |
| +<suite.member href="hc_attrinsertbefore4.xml"/> |
| +<suite.member href="hc_attrinsertbefore5.xml"/> |
| +<suite.member href="hc_attrinsertbefore6.xml"/> |
| +<suite.member href="hc_attrinsertbefore7.xml"/> |
| +<suite.member href="hc_attrlastchild.xml"/> |
| +<suite.member href="hc_attrnormalize.xml"/> |
| +<suite.member href="hc_attrremovechild1.xml"/> |
| +<suite.member href="hc_attrremovechild2.xml"/> |
| +<suite.member href="hc_attrreplacechild1.xml"/> |
| +<suite.member href="hc_attrreplacechild2.xml"/> |
| +<suite.member href="hc_attrsetvalue1.xml"/> |
| +<suite.member href="hc_attrsetvalue2.xml"/> |
| +<suite.member href="attrremovechild1.xml"/> |
| +<suite.member href="attrreplacechild1.xml"/> |
| + |
| +</suite> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrcreatedocumentfragment.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrcreatedocumentfragment"> |
| <metadata> |
| <title>attrCreateDocumentFragment</title> |
| <creator>NIST</creator> |
| <description> |
| Attr nodes may be associated with Element nodes contained within a DocumentFragment. |
| Create a new DocumentFragment and add a newly created Element node(with one attribute). |
| Once the element is added, its attribute should be available as an attribute associated |
| with an Element within a DocumentFragment. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- createDocumentFragment --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-35CB04B5"/> |
| <!-- setAttribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| <!-- DocumentFragment --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A3"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="newOne" type="Element"/> |
| <var name="domesticNode" type="Node"/> |
| <var name="domesticAttr" type="NamedNodeMap"/> |
| <var name="attrs" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="docFragment"/> |
| <createElement obj="doc" var="newOne" tagName=""newElement""/> |
| <setAttribute obj="newOne" name=""newdomestic"" value=""Yes""/> |
| <appendChild var="appendedChild" obj="docFragment" newChild="newOne"/> |
| <firstChild interface="Node" obj="docFragment" var="domesticNode"/> |
| <attributes obj="domesticNode" var="domesticAttr"/> |
| <item interface="NamedNodeMap" obj="domesticAttr" var="attrs" index="0"/> |
| <name interface="Attr" obj="attrs" var="attrName"/> |
| <assertEquals actual="attrName" expected=""newdomestic"" id="attrCreateDocumentFragmentAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrcreatetextnode.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrcreatetextnode"> |
| <metadata> |
| <title>attrCreateTextNode</title> |
| <creator>NIST</creator> |
| <description> |
| The "setValue()" method for an attribute creates a |
| Text node with the unparsed content of the string. |
| Retrieve the attribute named "street" from the last |
| child of of the fourth employee and assign the "Y&ent1;" |
| string to its value attribute. This value is not yet |
| parsed and therefore should still be the same upon |
| retrieval. This test uses the "getNamedItem(name)" method |
| from the NamedNodeMap interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- Attr.value --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-221662474"/> |
| <!-- bug report on initial version --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Apr/0057.html"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name=""street""/> |
| <value interface="Attr" obj="streetAttr" value='"Y&ent1;"'/> |
| <value interface="Attr" obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected='"Y&ent1;"' id="value" ignoreCase="false"/> |
| <nodeValue obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected='"Y&ent1;"' id="nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrcreatetextnode2.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrcreatetextnode2"> |
| <metadata> |
| <title>attrCreateTextNode2</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setNodeValue()" method for an attribute creates a |
| Text node with the unparsed content of the string. |
| Retrieve the attribute named "street" from the last |
| child of of the fourth employee and assign the "Y&ent1;" |
| string to its value attribute. This value is not yet |
| parsed and therefore should still be the same upon |
| retrieval. This test uses the "getNamedItem(name)" method |
| from the NamedNodeMap interface. |
| </description> |
| <date qualifier="created">2001-10-22</date> |
| <!-- Node.nodeValue --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <!-- bug report on initial version --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Apr/0057.html"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name=""street""/> |
| <nodeValue obj="streetAttr" value='"Y&ent1;"'/> |
| <value interface="Attr" obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected='"Y&ent1;"' id="value" ignoreCase="false"/> |
| <nodeValue obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected='"Y&ent1;"' id="nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrdefaultvalue.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrdefaultvalue"> |
| <metadata> |
| <title>attrDefaultValue</title> |
| <creator>NIST</creator> |
| <description> |
| If there is not an explicit value assigned to an attribute |
| and there is a declaration for this attribute and that |
| declaration includes a default value, then that default |
| value is the attributes default value. |
| Retrieve the attribute named "street" from the last |
| child of of the first employee and examine its |
| value. That value should be the value given the |
| attribute in the DTD file. The test uses the |
| "getNamedItem(name)" method from the NamedNodeMap |
| interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- Element.attributes --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- NamedNodeMap.getNamedItem --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1074577549"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name=""street""/> |
| <nodeValue obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected=""Yes"" id="attrDefaultValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attreffectivevalue.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attreffectivevalue"> |
| <metadata> |
| <title>attrEffectiveValue</title> |
| <creator>NIST</creator> |
| <description> |
| If an Attr is explicitly assigned any value, then that value is the attributes effective value. |
| Retrieve the attribute named "domestic" from the last child of of the first employee |
| and examine its nodeValue attribute. This test uses the "getNamedItem(name)" method |
| from the NamedNodeMap interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- Element.attributes --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- NamedNodeMap.getNamedItem --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1074577549"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name=""domestic""/> |
| <nodeValue obj="domesticAttr" var="value"/> |
| <assertEquals actual="value" expected=""Yes"" id="attrEffectiveValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrentityreplacement.xml.notimpl |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrentityreplacement"> |
| <metadata> |
| <title>attrEntityReplacement</title> |
| <creator>NIST</creator> |
| <description> |
| The "getValue()" method will return the value of the |
| attribute as a string. The general entity references |
| are replaced with their values. |
| Retrieve the attribute named "street" from the last |
| child of of the fourth employee and examine the string |
| returned by the "getValue()" method. The value should |
| be set to "Yes" after the EntityReference is |
| replaced with its value. This test uses the |
| "getNamedItem(name)" method from the NamedNodeMap |
| interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- Attr.value --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-221662474"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name=""street""/> |
| <value interface="Attr" obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yes"' id="streetYes" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrname.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrname"> |
| <metadata> |
| <title>attrName</title> |
| <creator>NIST</creator> |
| <description> |
| The getNodeName() method of an Attribute node. |
| Retrieve the attribute named street from the last |
| child of of the second employee and examine its |
| NodeName. This test uses the getNamedItem(name) method from the NamedNodeMap |
| interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- Node.nodeName --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <!-- Attr.name --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1112119403"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="name" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="1"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name=""street""/> |
| <nodeName obj="streetAttr" var="name"/> |
| <assertEquals actual="name" expected=""street"" id="nodeName" ignoreCase="false"/> |
| <name obj="streetAttr" var="name" interface="Attr"/> |
| <assertEquals actual="name" expected=""street"" id="name" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrnextsiblingnull.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrnextsiblingnull"> |
| <metadata> |
| <title>attrNextSiblingNull</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNextSibling()" method for an Attr node should return null. |
| Retrieve the attribute named "domestic" from the last child of of the |
| first employee and examine its NextSibling node. This test uses the |
| "getNamedItem(name)" method from the NamedNodeMap interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--nextSibling attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6AC54C2F"/> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="s" type="Node"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name=""domestic""/> |
| <nextSibling interface="Node" obj="domesticAttr" var="s"/> |
| <assertNull actual="s" id="attrNextSiblingNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrnotspecifiedvalue.xml.kfail |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrnotspecifiedvalue"> |
| <metadata> |
| <title>attrNotSpecifiedValue</title> |
| <creator>NIST</creator> |
| <description> |
| The "getSpecified()" method for an Attr node should |
| be set to false if the attribute was not explicitly given |
| a value. |
| Retrieve the attribute named "street" from the last |
| child of of the first employee and examine the value |
| returned by the "getSpecified()" method. This test uses |
| the "getNamedItem(name)" method from the NamedNodeMap |
| interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-862529273"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name='"street"'/> |
| <specified obj="streetAttr" var="state"/> |
| <assertFalse actual="state" id="streetNotSpecified"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrparentnodenull.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrparentnodenull"> |
| <metadata> |
| <title>attrParentNodeNull</title> |
| <creator>NIST</creator> |
| <description> |
| The "getParentNode()" method for an Attr node should return null. Retrieve |
| the attribute named "domestic" from the last child of the first employee |
| and examine its parentNode attribute. This test also uses the "getNamedItem(name)" |
| method from the NamedNodeMap interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--parentNode attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1060184317"/> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="s" type="Node"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name=""domestic""/> |
| <parentNode interface="Node" obj="domesticAttr" var="s"/> |
| <assertNull actual="s" id="attrParentNodeNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrprevioussiblingnull.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrprevioussiblingnull"> |
| <metadata> |
| <title>attrPreviousSiblingNull</title> |
| <creator>NIST</creator> |
| <description> |
| The "getPreviousSibling()" method for an Attr node should return null. |
| Retrieve the attribute named "domestic" from the last child of of the |
| first employee and examine its PreviousSibling node. This test uses the |
| "getNamedItem(name)" method from the NamedNodeMap interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--previousSibling attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-640FB3C8"/> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="s" type="Node"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name=""domestic""/> |
| <previousSibling interface="Node" obj="domesticAttr" var="s"/> |
| <assertNull actual="s" id="attrPreviousSiblingNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrremovechild1.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrremovechild1"> |
| <metadata> |
| <title>attrremovechild1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Removing a child node from an attribute in an entity reference |
| should result in an NO_MODIFICATION_ALLOWED_ERR DOMException. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1734834066')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <var name="attrNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference obj="doc" var="entRef" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <firstChild var="entElement" obj="entRef" interface="Node"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <getAttributeNode var="attrNode" obj="entElement" name='"domestic"'/> |
| <firstChild var="textNode" obj="attrNode" interface="Node"/> |
| <assertNotNull actual="textNode" id="attrChildNotNull"/> |
| <assertDOMException id="setValue_throws_NO_MODIFICATION_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild obj="attrNode" oldChild="textNode" var="removedNode"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrreplacechild1.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrreplacechild1"> |
| <metadata> |
| <title>attrreplacechild1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Replacing a child node from an attribute in an entity reference |
| should result in an NO_MODIFICATION_ALLOWED_ERR DOMException. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <var name="attrNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="removedNode" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference obj="doc" var="entRef" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <firstChild var="entElement" obj="entRef" interface="Node"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <getAttributeNode var="attrNode" obj="entElement" name='"domestic"'/> |
| <firstChild var="textNode" obj="attrNode" interface="Node"/> |
| <assertNotNull actual="textNode" id="attrChildNotNull"/> |
| <createTextNode var="newChild" obj="doc" data='"Yesterday"'/> |
| <assertDOMException id="setValue_throws_NO_MODIFICATION_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="attrNode" oldChild="textNode" var="removedNode" newChild="newChild"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrsetvaluenomodificationallowederr.xml.notimpl |
|---|
| 0,0 → 1,69 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrsetvaluenomodificationallowederr"> |
| <metadata> |
| <title>attrSetValueNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "setValue()" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the "domestic" attribute |
| from the entity reference and execute the "setValue()" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one-core#ID-221662474"/> |
| <subject resource="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one-core#xpointer(id('ID-221662474')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/DOM/updates/REC-DOM-Level-1-19981001-errata.html"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-221662474"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="genList" type="NodeList"/> |
| <var name="gen" type="Node"/> |
| <var name="gList" type="NodeList"/> |
| <var name="g" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <var name="attrNode" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <assertNotNull actual="gender" id="genderNotNull"/> |
| <childNodes obj="gender" var="genList"/> |
| <item interface="NodeList" obj="genList" var="gen" index="0"/> |
| <assertNotNull actual="gen" id="genderFirstChildNotNull"/> |
| <childNodes obj="gen" var="gList"/> |
| <item interface="NodeList" obj="gList" var="g" index="0"/> |
| <assertNotNull actual="g" id="genderFirstGrandchildNotNull"/> |
| <attributes obj="g" var="attrList"/> |
| <assertNotNull actual="attrList" id="attributesNotNull"/> |
| <getNamedItem obj="attrList" var="attrNode" name='"domestic"'/> |
| <assertNotNull actual="attrNode" id="attrNotNull"/> |
| <assertDOMException id="setValue_throws_NO_MODIFICATION"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <value interface="Attr" obj="attrNode" value='"newvalue"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="setNodeValue_throws_NO_MODIFICATION"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <nodeValue interface="Node" obj="attrNode" value='"newvalue2"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrsetvaluenomodificationallowederrEE.xml.notimpl |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrsetvaluenomodificationallowederrEE"> |
| <metadata> |
| <title>attrSetValueNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setValue()" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Create an entity reference using document.createEntityReference() |
| Get the "domestic" attribute from the entity |
| reference and execute the "setValue()" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-22</date> |
| <subject resource="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one-core#ID-221662474"/> |
| <subject resource="http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/level-one-core#xpointer(id('ID-221662474')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/DOM/updates/REC-DOM-Level-1-19981001-errata.html"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-221662474"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/attrsetvaluenomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <var name="attrNode" type="Node"/> |
| <var name="gender" type="Node"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <assertNotNull actual="gender" id="genderNotNull"/> |
| <createEntityReference obj="doc" var="entRef" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <appendChild obj="gender" newChild="entRef" var="appendedChild"/> |
| <firstChild obj="entRef" var="entElement" interface="Node"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <attributes obj="entElement" var="attrList"/> |
| <getNamedItem obj="attrList" var="attrNode" name=""domestic""/> |
| <assertDOMException id="setValue_throws_NO_MODIFICATION"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <value interface="Attr" obj="attrNode" value='"newvalue"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="setNodeValue_throws_NO_MODIFICATION"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <nodeValue interface="Node" obj="attrNode" value='"newvalue2"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrspecifiedvalue.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrspecifiedvalue"> |
| <metadata> |
| <title>attrSpecifiedValue</title> |
| <creator>NIST</creator> |
| <description> |
| The "getSpecified()" method for an Attr node should |
| be set to true if the attribute was explicitly given |
| a value. |
| Retrieve the attribute named "domestic" from the last |
| child of of the first employee and examine the value |
| returned by the "getSpecified()" method. This test uses |
| the "getNamedItem(name)" method from the NamedNodeMap |
| interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-862529273"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name='"domestic"'/> |
| <specified obj="domesticAttr" var="state"/> |
| <assertTrue actual="state" id="domesticSpecified"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrspecifiedvaluechanged.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrspecifiedvaluechanged"> |
| <metadata> |
| <title>attrSpecifiedValueChanged</title> |
| <creator>NIST</creator> |
| <description> |
| The "getSpecified()" method for an Attr node should return true if the |
| value of the attribute is changed. |
| Retrieve the attribute named "street" from the last |
| child of of the THIRD employee and change its |
| value to "Yes"(which is the default DTD value). This |
| should cause the "getSpecified()" method to be true. |
| This test uses the "setAttribute(name,value)" method |
| from the Element interface and the "getNamedItem(name)" |
| method from the NamedNodeMap interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-862529273"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="2"/> |
| <setAttribute obj="testNode" name=""street"" value=""Yes""/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name=""street""/> |
| <specified obj="streetAttr" var="state"/> |
| <assertTrue actual="state" id="streetSpecified"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/attrspecifiedvalueremove.xml.kfail |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="attrspecifiedvalueremove"> |
| <metadata> |
| <title>attrSpecifiedValueRemove</title> |
| <creator>NIST</creator> |
| <description> |
| To respecify the attribute to its default value from |
| the DTD, the attribute must be deleted. This will then |
| make a new attribute available with the "getSpecified()" |
| method value set to false. |
| Retrieve the attribute named "street" from the last |
| child of of the THIRD employee and delete it. This |
| should then create a new attribute with its default |
| value and also cause the "getSpecified()" method to |
| return false. |
| This test uses the "removeAttribute(name)" method |
| from the Element interface and the "getNamedItem(name)" |
| method from the NamedNodeMap interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--removeAttribute--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D6AC0F9"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="2"/> |
| <removeAttribute obj="testNode" name=""street""/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name=""street""/> |
| <assertNotNull actual="streetAttr" id="streetAttrNotNull"/> |
| <specified obj="streetAttr" var="state"/> |
| <assertFalse actual="state" id="attrSpecifiedValueRemoveAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/cdatasectiongetdata.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="cdatasectiongetdata"> |
| <metadata> |
| <title>cdataSectionGetValue</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the last CDATASection node located inside the |
| second child of the second employee and examine its |
| content. Since the CDATASection interface inherits |
| from the CharacterData interface(via the Text node), |
| the "getData()" method can be used to access the |
| CDATA content. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| </metadata> |
| <implementationAttribute name="coalescing" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <var name="data" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nameList" tagname=""name""/> |
| <item interface="NodeList" obj="nameList" var="child" index="1"/> |
| <lastChild interface="Node" obj="child" var="lastChild"/> |
| <nodeType var="nodeType" obj="lastChild"/> |
| <assertEquals actual="nodeType" expected="4" id="isCDATA" ignoreCase="false"/> |
| <data interface="CharacterData" obj="lastChild" var="data"/> |
| <assertEquals actual="data" expected='"This is an adjacent CDATASection with a reference to a tab &tab;"' id="data" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/cdatasectionnormalize.xml.notimpl |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="cdatasectionnormalize"> |
| <metadata> |
| <title>cdataSectionNormalize</title> |
| <creator>NIST</creator> |
| <description> |
| Adjacent CDATASection nodes cannot be merged together by |
| use of the "normalize()" method from the Element interface. |
| Retrieve second child of the second employee and invoke |
| the "normalize()" method. The Element under contains |
| two CDATASection nodes that should not be merged together |
| by the "normalize()" method. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-162CF083"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <var name="lChild" type="Element"/> |
| <var name="childNodes" type="NodeList"/> |
| <var name="cdataN" type="CDATASection"/> |
| <var name="data" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nameList" tagname=""name""/> |
| <item interface="NodeList" obj="nameList" var="lChild" index="1"/> |
| <normalize obj="lChild"/> |
| <childNodes obj="lChild" var="childNodes"/> |
| <item interface="NodeList" obj="childNodes" var="cdataN" index="1"/> |
| <assertNotNull actual="cdataN" id="firstCDATASection"/> |
| <data interface="CharacterData" obj="cdataN" var="data"/> |
| <assertEquals actual="data" expected='"This is a CDATASection with EntityReference number 2 &ent2;"' ignoreCase="false" id="data1"/> |
| <item interface="NodeList" obj="childNodes" var="cdataN" index="3"/> |
| <assertNotNull actual="cdataN" id="secondCDATASection"/> |
| <data interface="CharacterData" obj="cdataN" var="data"/> |
| <assertEquals actual="data" expected='"This is an adjacent CDATASection with a reference to a tab &tab;"' ignoreCase="false" id="data3"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataappenddata.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataappenddata"> |
| <metadata> |
| <title>characterdataAppendData</title> |
| <creator>NIST</creator> |
| <description> |
| The "appendData(arg)" method appends a string to the end |
| of the character data of the node. |
| Retrieve the character data from the second child |
| of the first employee. The appendData(arg) method is |
| called with arg=", Esquire". The method should append |
| the specified data to the already existing character |
| data. The new value return by the "getLength()" method |
| should be 24. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-32791A2F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="childLength" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <appendData obj="child" arg="", Esquire""/> |
| <data obj="child" var="childValue" interface="CharacterData"/> |
| <length obj="childValue" var="childLength" interface="DOMString"/> |
| <assertEquals actual="childLength" expected="24" ignoreCase="false" id="characterdataAppendDataAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataappenddatagetdata.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataappenddatagetdata"> |
| <metadata> |
| <title>characterdataAppendDataGetData</title> |
| <creator>NIST</creator> |
| <description> |
| On successful invocation of the "appendData(arg)" |
| method the "getData()" method provides access to the |
| concatentation of data and the specified string. |
| Retrieve the character data from the second child |
| of the first employee. The appendData(arg) method is |
| called with arg=", Esquire". The method should append |
| the specified data to the already existing character |
| data. The new value return by the "getData()" method |
| should be "Margaret Martin, Esquire". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-32791A2F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <appendData obj="child" arg="", Esquire""/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""Margaret Martin, Esquire"" id="characterdataAppendDataGetDataAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataappenddatanomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataappenddatanomodificationallowederr"> |
| <metadata> |
| <title>characterdataAppendDataNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "appendData(arg)" method raises a NO_MODIFICATION_ALLOWED_ERR |
| DOMException if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the FIRST item |
| from the entity reference and execute the "appendData(arg)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-32791A2F"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-32791A2F')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-32791A2F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="entElementContent" type="Node"/> |
| <var name="entReference" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="2" var="genderNode"/> |
| <firstChild var="entReference" obj="genderNode" interface="Node"/> |
| <assertNotNull actual="entReference" id="entReferenceNotNull"/> |
| <nodeType var="nodeType" obj="entReference"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entReference" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entReference" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild var="entElement" obj="entReference" interface="Node"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <firstChild var="entElementContent" obj="entElement" interface="Node"/> |
| <assertNotNull actual="entElementContent" id="entElementContentNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <appendData obj="entElementContent" arg=""newString""/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataappenddatanomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataappenddatanomodificationallowederrEE"> |
| <metadata> |
| <title>characterdataAppendDataNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create an ent3 entity reference and call appendData on a text child, should thrown a NO_MODIFICATION_ALLOWED_ERR. |
| </description> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-32791A2F"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-32791A2F')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-32791A2F"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/characterdataappenddatanomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entText" type="Node"/> |
| <var name="entReference" type="EntityReference"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="2" var="genderNode"/> |
| <createEntityReference var="entReference" obj="doc" name='"ent3"'/> |
| <assertNotNull actual="entReference" id="createdEntRefNotNull"/> |
| <appendChild obj="genderNode" newChild="entReference" var="appendedChild"/> |
| <firstChild var="entText" obj="entReference" interface="Node"/> |
| <assertNotNull actual="entText" id="entTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <appendData obj="entText" arg='"newString"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatadeletedatabegining.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatadeletedatabegining"> |
| <metadata> |
| <title>characterdataDeleteDataBeginning</title> |
| <creator>NIST</creator> |
| <description> |
| The "deleteData(offset,count)" method removes a range of |
| characters from the node. Delete data at the beginning |
| of the character data. |
| Retrieve the character data from the last child of the |
| first employee. The "deleteData(offset,count)" |
| method is then called with offset=0 and count=16. |
| The method should delete the characters from position |
| 0 thru position 16. The new value of the character data |
| should be "Dallas, Texas 98551". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <deleteData obj="child" offset="0" count="16"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""Dallas, Texas 98551"" id="characterdataDeleteDataBeginingAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatadeletedataend.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatadeletedataend"> |
| <metadata> |
| <title>characterdataDeleteDataEnd</title> |
| <creator>NIST</creator> |
| <description> |
| The "deleteData(offset,count)" method removes a range of |
| characters from the node. Delete data at the end |
| of the character data. |
| Retrieve the character data from the last child of the |
| first employee. The "deleteData(offset,count)" |
| method is then called with offset=30 and count=5. |
| The method should delete the characters from position |
| 30 thru position 35. The new value of the character data |
| should be "1230 North Ave. Dallas, Texas". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <deleteData obj="child" offset="30" count="5"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""1230 North Ave. Dallas, Texas "" id="characterdataDeleteDataEndAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatadeletedataexceedslength.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatadeletedataexceedslength"> |
| <metadata> |
| <title>characterdataDeleteDataExceedsLength</title> |
| <creator>NIST</creator> |
| <description> |
| If the sum of the offset and count used in the |
| "deleteData(offset,count) method is greater than the |
| length of the character data then all the characters |
| from the offset to the end of the data are deleted. |
| Retrieve the character data from the last child of the |
| first employee. The "deleteData(offset,count)" |
| method is then called with offset=4 and count=50. |
| The method should delete the characters from position 4 |
| to the end of the data since the offset+count(50+4) |
| is greater than the length of the character data(35). |
| The new value of the character data should be "1230". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <deleteData obj="child" offset="4" count="50"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""1230"" id="characterdataDeleteDataExceedsLengthAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatadeletedatagetlengthanddata.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatadeletedatagetlengthanddata"> |
| <metadata> |
| <title>characterdataDeleteDataGetLengthAndData</title> |
| <creator>NIST</creator> |
| <description> |
| On successful invocation of the "deleteData(offset,count)" |
| method, the "getData()" and "getLength()" methods reflect |
| the changes. |
| Retrieve the character data from the last child of the |
| first employee. The "deleteData(offset,count)" |
| method is then called with offset=30 and count=5. |
| The method should delete the characters from position |
| 30 thru position 35. The new value of the character data |
| should be "1230 North Ave. Dallas, Texas" which is |
| returned by the "getData()" method and "getLength()" |
| method should return 30". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7D61178C"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <var name="childLength" type="int"/> |
| <var name="result" type="List"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <deleteData obj="child" offset="30" count="5"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""1230 North Ave. Dallas, Texas "" ignoreCase="false" id="data"/> |
| <length interface="CharacterData" obj="child" var="childLength"/> |
| <assertEquals actual="childLength" expected="30" ignoreCase="false" id="length"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatadeletedatamiddle.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatadeletedatamiddle"> |
| <metadata> |
| <title>characterdataDeleteDataMiddle</title> |
| <creator>NIST</creator> |
| <description> |
| The "deleteData(offset,count)" method removes a range of |
| characters from the node. Delete data in the middle |
| of the character data. |
| Retrieve the character data from the last child of the |
| first employee. The "deleteData(offset,count)" |
| method is then called with offset=16 and count=8. |
| The method should delete the characters from position |
| 16 thru position 24. The new value of the character data |
| should be "1230 North Ave. Texas 98551". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <deleteData obj="child" offset="16" count="8"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""1230 North Ave. Texas 98551"" id="characterdataDeleteDataMiddleAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatadeletedatanomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatadeletedatanomodificationallowederr"> |
| <metadata> |
| <title>characterdataDeleteDataNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "deleteData(offset,count)" method raises a NO_MODIFICATION_ALLOWED_ERR |
| DOMException if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the FIRST item |
| from the entity reference and execute the "deleteData(offset,count)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-7C603781')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="entElementContent" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="entReference" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="2" var="genderNode"/> |
| <firstChild var="entReference" obj="genderNode" interface="Node"/> |
| <assertNotNull actual="entReference" id="entReferenceNotNull"/> |
| <nodeType var="nodeType" obj="entReference"/> |
| <if><equals actual="nodeType" expected="3"/> |
| <createEntityReference var="entReference" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entReference" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild var="entElement" obj="entReference" interface="Node"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <firstChild var="entElementContent" obj="entElement" interface="Node"/> |
| <assertNotNull actual="entElementContent" id="entElementContentNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <deleteData obj="entElementContent" offset="1" count="3"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatadeletedatanomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatadeletedatanomodificationallowederrEE"> |
| <metadata> |
| <title>characterdataDeleteDataNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create an ent3 entity reference and call deleteData on a text child, should thrown a NO_MODIFICATION_ALLOWED_ERR. |
| </description> |
| <date qualifier="created">2001-08-20</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-7C603781')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/characterdatadeletedatanomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entText" type="Node"/> |
| <var name="entReference" type="EntityReference"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="2" var="genderNode"/> |
| <createEntityReference obj="doc" var="entReference" name='"ent3"'/> |
| <assertNotNull actual="entReference" id="createdEntRefNotNull"/> |
| <appendChild obj="genderNode" newChild="entReference" var="appendedChild"/> |
| <firstChild var="entText" obj="entReference" interface="Node"/> |
| <assertNotNull actual="entText" id="entTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <deleteData obj="entText" offset="1" count="3"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatagetdata.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatagetdata"> |
| <metadata> |
| <title>characterdataGetData</title> |
| <creator>NIST</creator> |
| <description> |
| The "getData()" method retrieves the character data |
| currently stored in the node. |
| Retrieve the character data from the second child |
| of the first employee and invoke the "getData()" |
| method. The method returns the character data |
| string. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""Margaret Martin"" id="characterdataGetDataAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatagetlength.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatagetlength"> |
| <metadata> |
| <title>characterdataGetLength</title> |
| <creator>NIST</creator> |
| <description> |
| The "getLength()" method returns the number of characters |
| stored in this nodes data. |
| Retrieve the character data from the second |
| child of the first employee and examine the |
| value returned by the getLength() method. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7D61178C"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="childLength" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <data var="childValue" obj="child" interface="CharacterData"/> |
| <length var="childLength" obj="childValue" interface="DOMString"/> |
| <assertEquals actual="childLength" expected="15" ignoreCase="false" id="characterdataGetLengthAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrdeletedatacountnegative.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrdeletedatacountnegative"> |
| <metadata> |
| <title>characterdataIndexSizeErrDeleteDataCountNegative</title> |
| <creator>NIST</creator> |
| <description> |
| The "deleteData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified count |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "deleteData(offset,count)" |
| method with offset=10 and count=-3. It should raise the |
| desired exception since the count is negative. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6531BCCF')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <deleteData obj="child" offset="10" count="-3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrdeletedataoffsetgreater.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrdeletedataoffsetgreater"> |
| <metadata> |
| <title>characterdataIndexSizeErrDeleteDataOffsetGreater</title> |
| <creator>NIST</creator> |
| <description> |
| The "deleteData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is greater that the number of characters in the string. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "deleteData(offset,count)" |
| method with offset=40 and count=3. It should raise the |
| desired exception since the offset is greater than the |
| number of characters in the string. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-7C603781')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throw_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <deleteData obj="child" offset="40" count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrdeletedataoffsetnegative.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrdeletedataoffsetnegative"> |
| <metadata> |
| <title>characterdataIndexSizeErrDeleteDataOffsetNegative</title> |
| <creator>NIST</creator> |
| <description> |
| The "deleteData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "deleteData(offset,count)" |
| method with offset=-5 and count=3. It should raise the |
| desired exception since the offset is negative. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-7C603781')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <deleteData obj="child" offset="-5" count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrinsertdataoffsetgreater.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrinsertdataoffsetgreater"> |
| <metadata> |
| <title>characterdataIndexSizeErrInsertDataOffsetGreater</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertData(offset,arg)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is greater than the number of characters in the string. |
| Retrieve the character data of the last child of the |
| first employee and invoke its insertData"(offset,arg)" |
| method with offset=40 and arg="ABC". It should raise |
| the desired exception since the offset is greater than |
| the number of characters in the string. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-7C603781')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throw_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <insertData obj="child" offset="40" arg=""ABC""/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrinsertdataoffsetnegative.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrinsertdataoffsetnegative"> |
| <metadata> |
| <title>characterdataIndexSizeErrInsertDataOffsetNegative</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertData(offset,arg)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its insertData"(offset,arg)" |
| method with offset=-5 and arg="ABC". It should raise |
| the desired exception since the offset is negative. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-E5CBA7FB')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <insertData obj="child" offset="-5" arg=""ABC""/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrreplacedatacountnegative.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrreplacedatacountnegative"> |
| <metadata> |
| <title>characterdataIndexSizeErrReplaceDataCountNegative</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified count |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its |
| "replaceData(offset,count,arg) method with offset=10 |
| and count=-3 and arg="ABC". It should raise the |
| desired exception since the count is negative. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6531BCCF')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <replaceData obj="child" offset="10" count="-3" arg=""ABC""/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrreplacedataoffsetgreater.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrreplacedataoffsetgreater"> |
| <metadata> |
| <title>characterdataIndexSizeErrReplaceDataOffsetGreater</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is greater than the length of the string. |
| Retrieve the character data of the last child of the |
| first employee and invoke its |
| "replaceData(offset,count,arg) method with offset=40 |
| and count=3 and arg="ABC". It should raise the |
| desired exception since the offset is greater than the |
| length of the string. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-7C603781')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throw_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <replaceData obj="child" offset="40" count="3" arg=""ABC""/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrreplacedataoffsetnegative.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrreplacedataoffsetnegative"> |
| <metadata> |
| <title>characterdataIndexSizeErrReplaceDataOffsetNegative</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its |
| "replaceData(offset,count,arg) method with offset=-5 |
| and count=3 and arg="ABC". It should raise the |
| desired exception since the offset is negative. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-E5CBA7FB')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <replaceData obj="child" offset="-5" count="3" arg=""ABC""/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrsubstringcountnegative.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrsubstringcountnegative"> |
| <metadata> |
| <title>characterdataIndexSizeErrSubstringCountNegative</title> |
| <creator>NIST</creator> |
| <description> |
| The "substringData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified count |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "substringData(offset,count) |
| method with offset=10 and count=-3. It should raise the |
| desired exception since the count is negative. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6531BCCF')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="badSubstring" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <substringData var="badSubstring" obj="child" offset="10" count="-3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrsubstringnegativeoffset.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrsubstringnegativeoffset"> |
| <metadata> |
| <title>characterdataIndexSizeErrSubstringNegativeOffset</title> |
| <creator>NIST</creator> |
| <description> |
| The "substringData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "substringData(offset,count) |
| method with offset=-5 and count=3. It should raise the |
| desired exception since the offset is negative. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6531BCCF')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="badString" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <substringData var="badString" obj="child" offset="-5" count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdataindexsizeerrsubstringoffsetgreater.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdataindexsizeerrsubstringoffsetgreater"> |
| <metadata> |
| <title>characterdataIndexSizeErrSubstringOffsetGreater</title> |
| <creator>NIST</creator> |
| <description> |
| The "substringData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is greater than the number of characters in the string. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "substringData(offset,count) |
| method with offset=40 and count=3. It should raise the |
| desired exception since the offsets value is greater |
| than the length. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6531BCCF')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="badString" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throw_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <substringData var="badString" obj="child" offset="40" count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatainsertdatabeginning.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatainsertdatabeginning"> |
| <metadata> |
| <title>characterdataInsertDataBeginning</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertData(offset,arg)" method will insert a string |
| at the specified character offset. Insert the data at |
| the beginning of the character data. |
| Retrieve the character data from the second child of |
| the first employee. The "insertData(offset,arg)" |
| method is then called with offset=0 and arg="Mss.". |
| The method should insert the string "Mss." at position 0. |
| The new value of the character data should be |
| "Mss. Margaret Martin". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--insertData--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3EDB695F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <insertData obj="child" offset="0" arg=""Mss. ""/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""Mss. Margaret Martin"" id="characterdataInsertDataBeginningAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatainsertdataend.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatainsertdataend"> |
| <metadata> |
| <title>characterdataInsertDataEnd</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertData(offset,arg)" method will insert a string |
| at the specified character offset. Insert the data at |
| the end of the character data. |
| Retrieve the character data from the second child of |
| the first employee. The "insertData(offset,arg)" |
| method is then called with offset=15 and arg=", Esquire". |
| The method should insert the string ", Esquire" at |
| position 15. The new value of the character data should |
| be "Margaret Martin, Esquire". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3EDB695F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <insertData obj="child" offset="15" arg="", Esquire""/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""Margaret Martin, Esquire"" id="characterdataInsertDataEndAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatainsertdatamiddle.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatainsertdatamiddle"> |
| <metadata> |
| <title>characterdataInsertDataMiddle</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertData(offset,arg)" method will insert a string |
| at the specified character offset. Insert the data in |
| the middle of the character data. |
| Retrieve the character data from the second child of |
| the first employee. The "insertData(offset,arg)" |
| method is then called with offset=9 and arg="Ann". |
| The method should insert the string "Ann" at position 9. |
| The new value of the character data should be |
| "Margaret Ann Martin". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3EDB695F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <insertData obj="child" offset="9" arg=""Ann ""/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""Margaret Ann Martin"" id="characterdataInsertDataMiddleAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatainsertdatanomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatainsertdatanomodificationallowederr"> |
| <metadata> |
| <title>characterdataInsertDataNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertData(offset,arg)" method raises a NO_MODIFICATION_ALLOWED_ERR |
| DOMException if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the FIRST item |
| from the entity reference and execute the "insertData(offset,arg)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3EDB695F"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-3EDB695F')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3EDB695F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="entElementContent" type="Node"/> |
| <var name="entReference" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"gender"' var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="2" var="genderNode"/> |
| <firstChild var="entReference" obj="genderNode" interface="Node"/> |
| <assertNotNull actual="entReference" id="entReferenceNotNull"/> |
| <nodeType var="nodeType" obj="entReference"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entReference" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entReference" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild var="entElement" obj="entReference" interface="Node"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <firstChild var="entElementContent" obj="entElement" interface="Node"/> |
| <assertNotNull actual="entElementContent" id="entElementContentNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertData obj="entElementContent" offset="1" arg='"newArg"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatainsertdatanomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatainsertdatanomodificationallowederrEE"> |
| <metadata> |
| <title>characterdataInsertDataNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create an ent3 entity reference and call insertData on a text child, should thrown a NO_MODIFICATION_ALLOWED_ERR. |
| </description> |
| <date qualifier="created">2001-08-20</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3EDB695F"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-3EDB695F')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3EDB695F"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/characterdatainsertdatanomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entText" type="CharacterData"/> |
| <var name="entReference" type="EntityReference"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="2" var="genderNode"/> |
| <createEntityReference var="entReference" obj="doc" name='"ent3"'/> |
| <assertNotNull actual="entReference" id="createdEntRefNotNull"/> |
| <firstChild var="entText" obj="entReference" interface="Node"/> |
| <assertNotNull actual="entText" id="entTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertData obj="entText" offset="1" arg=""newArg""/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatareplacedatabegining.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatareplacedatabegining"> |
| <metadata> |
| <title>characterdataReplaceDataBeginning</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method replaces the |
| characters starting at the specified offset with the |
| specified string. Test for replacement in the |
| middle of the data. |
| Retrieve the character data from the last child of the |
| first employee. The "replaceData(offset,count,arg)" |
| method is then called with offset=5 and count=5 and |
| arg="South". The method should replace characters five |
| thru 9 of the character data with "South". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--replaceData--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <replaceData obj="child" offset="0" count="4" arg=""2500""/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""2500 North Ave. Dallas, Texas 98551"" id="characterdataReplaceDataBeginingAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatareplacedataend.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatareplacedataend"> |
| <metadata> |
| <title>characterdataReplaceDataEnd</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method replaces the |
| characters starting at the specified offset with the |
| specified string. Test for replacement at the |
| end of the data. |
| Retrieve the character data from the last child of the |
| first employee. The "replaceData(offset,count,arg)" |
| method is then called with offset=30 and count=5 and |
| arg="98665". The method should replace characters 30 |
| thru 34 of the character data with "98665". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <replaceData obj="child" offset="30" count="5" arg=""98665""/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""1230 North Ave. Dallas, Texas 98665"" id="characterdataReplaceDataEndAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatareplacedataexceedslengthofarg.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatareplacedataexceedslengthofarg"> |
| <metadata> |
| <title>characterdataReplaceDataExceedsLengthOfArg</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method replaces the |
| characters starting at the specified offset with the |
| specified string. Test the situation where the length |
| of the arg string is greater than the specified offset. |
| Retrieve the character data from the last child of the |
| first employee. The "replaceData(offset,count,arg)" |
| method is then called with offset=0 and count=4 and |
| arg="260030". The method should replace characters one |
| thru four with "260030". Note that the length of the |
| specified string is greater that the specified offset. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <replaceData obj="child" offset="0" count="4" arg=""260030""/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""260030 North Ave. Dallas, Texas 98551"" id="characterdataReplaceDataExceedsLengthOfArgAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatareplacedataexceedslengthofdata.xml.kfail |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatareplacedataexceedslengthofdata"> |
| <metadata> |
| <title>characterdataReplaceDataExceedsLengthOfData</title> |
| <creator>NIST</creator> |
| <description> |
| If the sum of the offset and count exceeds the length then |
| all the characters to the end of the data are replaced. |
| Retrieve the character data from the last child of the |
| first employee. The "replaceData(offset,count,arg)" |
| method is then called with offset=0 and count=50 and |
| arg="2600". The method should replace all the characters |
| with "2600". This is because the sum of the offset and |
| count exceeds the length of the character data. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <replaceData obj="child" offset="0" count="50" arg=""2600""/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""2600"" id="characterdataReplaceDataExceedsLengthOfDataAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatareplacedatamiddle.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatareplacedatamiddle"> |
| <metadata> |
| <title>characterdataReplaceDataMiddle</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method replaces the |
| characters starting at the specified offset with the |
| specified string. Test for replacement in the |
| middle of the data. |
| Retrieve the character data from the last child of the |
| first employee. The "replaceData(offset,count,arg)" |
| method is then called with offset=5 and count=5 and |
| arg="South". The method should replace characters five |
| thru 9 of the character data with "South". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <replaceData obj="child" offset="5" count="5" arg=""South""/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""1230 South Ave. Dallas, Texas 98551"" id="characterdataReplaceDataMiddleAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatareplacedatanomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatareplacedatanomodificationallowederr"> |
| <metadata> |
| <title>characterdataReplaceDataNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method raises a NO_MODIFICATION_ALLOWED_ERR |
| DOMException if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the FIRST item |
| from the entity reference and execute the "replaceData(offset,count,arg)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-E5CBA7FB')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="entElementContent" type="Node"/> |
| <var name="entReference" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"gender"' var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="2" var="genderNode"/> |
| <firstChild interface="Node" var="entReference" obj="genderNode"/> |
| <assertNotNull actual="entReference" id="entReferenceNotNull"/> |
| <nodeType var="nodeType" obj="entReference"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entReference" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entReference" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild var="entElement" obj="entReference" interface="Node"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <firstChild var="entElementContent" obj="entElement" interface="Node"/> |
| <assertNotNull actual="entElementContent" id="entElementContentNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceData obj="entElementContent" offset="1" count="3" arg=""newArg""/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatareplacedatanomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatareplacedatanomodificationallowederrEE"> |
| <metadata> |
| <title>characterdataReplaceDataNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create an ent3 entity reference and call replaceData on a text child, should thrown a NO_MODIFICATION_ALLOWED_ERR. |
| </description> |
| <date qualifier="created">2001-08-21</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-E5CBA7FB')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/characterdatareplacedatanomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entText" type="CharacterData"/> |
| <var name="entReference" type="EntityReference"/> |
| <var name="appendedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="2" var="genderNode"/> |
| <createEntityReference var="entReference" obj="doc" name='"ent3"'/> |
| <assertNotNull actual="entReference" id="createdEntRefNotNull"/> |
| <appendChild obj="genderNode" newChild="entReference" var="appendedNode"/> |
| <firstChild var="entText" obj="entReference" interface="Node"/> |
| <assertNotNull actual="entText" id="entTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceData obj="entText" offset="1" count="3" arg='"newArg"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatasetdatanomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatasetdatanomodificationallowederr"> |
| <metadata> |
| <title>characterdataSetDataNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "setData(data)" method raises a NO_MODIFICATION_ALLOWED_ERR |
| DOMException if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the FIRST item |
| from the entity reference and execute the "setData(data)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-72AB8359')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="entElementContent" type="Node"/> |
| <var name="entReference" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="2" var="genderNode"/> |
| <firstChild var="entReference" obj="genderNode" interface="Node"/> |
| <assertNotNull actual="entReference" id="entReferenceNotNull"/> |
| <nodeType var="nodeType" obj="entReference"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entReference" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entReference" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild var="entElement" obj="entReference" interface="Node"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <firstChild var="entElementContent" obj="entElement" interface="Node"/> |
| <assertNotNull actual="entElementContent" id="entElementContentNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <data interface="CharacterData" obj="entElementContent" value=""newData""/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatasetdatanomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatasetdatanomodificationallowederrEE"> |
| <metadata> |
| <title>characterdataSetDataNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create an ent3 entity reference and call setData on a text child, should thrown a NO_MODIFICATION_ALLOWED_ERR. |
| </description> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-72AB8359')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/characterdatasetdatanomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entText" type="Node"/> |
| <var name="entReference" type="EntityReference"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="4" var="genderNode"/> |
| <createEntityReference var="entReference" obj="doc" name='"ent3"'/> |
| <assertNotNull actual="entReference" id="createdEntRefNotNull"/> |
| <firstChild var="entText" obj="entReference" interface="Node"/> |
| <assertNotNull actual="entText" id="entTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <data interface="CharacterData" obj="entText" value=""newData""/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatasetnodevalue.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatasetnodevalue"> |
| <metadata> |
| <title>characterdataSetNodeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setNodeValue()" method changes the character data |
| currently stored in the node. |
| Retrieve the character data from the second child |
| of the first employee and invoke the "setNodeValue()" |
| method, call "getData()" and compare. |
| </description> |
| <date qualifier="created">2001-08-23</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <nodeValue obj="child" value=""Marilyn Martin""/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected=""Marilyn Martin"" id="data" ignoreCase="false"/> |
| <nodeValue obj="child" var="childValue"/> |
| <assertEquals actual="childValue" expected=""Marilyn Martin"" id="value" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatasubstringexceedsvalue.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatasubstringexceedsvalue"> |
| <metadata> |
| <title>characterdataSubStringExceedsValue</title> |
| <creator>NIST</creator> |
| <description> |
| If the sum of the "offset" and "count" exceeds the |
| "length" then the "substringData(offset,count)" method |
| returns all the characters to the end of the data. |
| Retrieve the character data from the second child |
| of the first employee and access part of the data |
| by using the substringData(offset,count) method |
| with offset=9 and count=10. The method should return |
| the substring "Martin" since offset+count > length |
| (19 > 15). |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--CharacterData.substringData--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="substring" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <substringData obj="child" var="substring" offset="9" count="10"/> |
| <assertEquals actual="substring" expected=""Martin"" id="characterdataSubStringExceedsValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/characterdatasubstringvalue.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="characterdatasubstringvalue"> |
| <metadata> |
| <title>characterdataSubStringValue</title> |
| <creator>NIST</creator> |
| <description> |
| The "substringData(offset,count)" method returns the |
| specified string. |
| Retrieve the character data from the second child |
| of the first employee and access part of the data |
| by using the substringData(offset,count) method. The |
| method should return the specified substring starting |
| at position "offset" and extract "count" characters. |
| The method should return the string "Margaret". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--CharacterData.substringData--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="substring" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <substringData obj="child" var="substring" offset="0" count="8"/> |
| <assertEquals actual="substring" expected=""Margaret"" id="characterdataSubStringValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/commentgetcomment.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="commentgetcomment"> |
| <metadata> |
| <title>commentGetComment</title> |
| <creator>NIST</creator> |
| <description> |
| A comment is all the characters between the starting |
| '<!--' and ending '-->' |
| Retrieve the nodes of the DOM document. Search for a |
| comment node and the content is its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- Comment interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1334481328"/> |
| <!--Node.nodeName attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <!--Node.nodeValue attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <!--Node.nodeType attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="commentCount" type="int" value="0"/> |
| <var name="childType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="elementList"/> |
| <for-each collection="elementList" member="child"> |
| <nodeType obj="child" var="childType"/> |
| <if> |
| <equals actual="childType" expected="8" ignoreCase="false"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"#comment"' ignoreCase="false" id="nodeName"/> |
| <nodeValue obj="child" var="childValue"/> |
| <assertEquals actual="childValue" expected="" This is comment number 1."" id="nodeValue" ignoreCase="false"/> |
| <plus var="commentCount" op1="commentCount" op2="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="commentCount" expected="1" ignoreCase="false" id="commentCount"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreateattribute.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreateattribute"> |
| <metadata> |
| <title>documentCreateAttribute</title> |
| <creator>NIST</creator> |
| <description> |
| The "createAttribute(name)" method creates an Attribute |
| node of the given name. |
| Retrieve the entire DOM document and invoke its |
| "createAttribute(name)" method. It should create a |
| new Attribute node with the given name. The name, value |
| and type of the newly created object are retrieved and |
| output. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1084891198"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newAttrNode" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="attrType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createAttribute obj="doc" var="newAttrNode" name=""district""/> |
| <nodeValue obj="newAttrNode" var="attrValue"/> |
| <assertEquals actual="attrValue" expected="""" ignoreCase="false" id="value"/> |
| <nodeName obj="newAttrNode" var="attrName"/> |
| <assertEquals actual="attrName" expected=""district"" ignoreCase="false" id="name"/> |
| <nodeType obj="newAttrNode" var="attrType"/> |
| <assertEquals actual="attrType" expected="2" ignoreCase="false" id="type"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreatecdatasection.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreatecdatasection"> |
| <metadata> |
| <title>documentCreateCDATASection</title> |
| <creator>NIST</creator> |
| <description> |
| The "createCDATASection(data)" method creates a new |
| CDATASection node whose value is the specified string. |
| Retrieve the entire DOM document and invoke its |
| "createCDATASection(data)" method. It should create a |
| new CDATASection node whose "data" is the specified |
| string. The content, name and type are retrieved and |
| output. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D26C0AF8"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newCDATASectionNode" type="CDATASection"/> |
| <var name="newCDATASectionValue" type="DOMString"/> |
| <var name="newCDATASectionName" type="DOMString"/> |
| <var name="newCDATASectionType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createCDATASection obj="doc" var="newCDATASectionNode" data=""This is a new CDATASection node""/> |
| <nodeValue obj="newCDATASectionNode" var="newCDATASectionValue"/> |
| <assertEquals id="nodeValue" actual="newCDATASectionValue" expected=""This is a new CDATASection node"" ignoreCase="false"/> |
| <nodeName obj="newCDATASectionNode" var="newCDATASectionName"/> |
| <assertEquals id="nodeName" actual="newCDATASectionName" expected=""#cdata-section"" ignoreCase="false"/> |
| <nodeType obj="newCDATASectionNode" var="newCDATASectionType"/> |
| <assertEquals id="nodeType" actual="newCDATASectionType" expected="4" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreatecomment.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreatecomment"> |
| <metadata> |
| <title>documentCreateComment</title> |
| <creator>NIST</creator> |
| <description> |
| The "createComment(data)" method creates a new Comment |
| node given the specified string. |
| Retrieve the entire DOM document and invoke its |
| "createComment(data)" method. It should create a new |
| Comment node whose "data" is the specified string. |
| The content, name and type are retrieved and output. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1334481328"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newCommentNode" type="Comment"/> |
| <var name="newCommentValue" type="DOMString"/> |
| <var name="newCommentName" type="DOMString"/> |
| <var name="newCommentType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createComment obj="doc" var="newCommentNode" data=""This is a new Comment node""/> |
| <nodeValue obj="newCommentNode" var="newCommentValue"/> |
| <assertEquals actual="newCommentValue" expected=""This is a new Comment node"" ignoreCase="false" id="value"/> |
| <nodeName obj="newCommentNode" var="newCommentName"/> |
| <assertEquals actual="newCommentName" expected=""#comment"" ignoreCase="false" id="name"/> |
| <nodeType obj="newCommentNode" var="newCommentType"/> |
| <assertEquals actual="newCommentType" expected="8" ignoreCase="false" id="type"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreatedocumentfragment.xml.int-broken |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreatedocumentfragment"> |
| <metadata> |
| <title>documentCreateDocumentFragment</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocumentFragment()" method creates an empty |
| DocumentFragment object. |
| Retrieve the entire DOM document and invoke its |
| "createDocumentFragment()" method. The content, name, |
| type and value of the newly created object are output. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-35CB04B5"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDocFragment" type="DocumentFragment"/> |
| <var name="children" type="NodeList"/> |
| <var name="length" type="int"/> |
| <var name="newDocFragmentName" type="DOMString"/> |
| <var name="newDocFragmentType" type="int"/> |
| <var name="newDocFragmentValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="newDocFragment"/> |
| <childNodes obj="newDocFragment" var="children"/> |
| <length interface="NodeList" obj="children" var="length"/> |
| <assertEquals actual="length" expected="0" ignoreCase="false" id="length"/> |
| <nodeName obj="newDocFragment" var="newDocFragmentName"/> |
| <assertEquals actual="newDocFragmentName" expected=""#document-fragment"" ignoreCase="false" id="name"/> |
| <nodeType obj="newDocFragment" var="newDocFragmentType"/> |
| <assertEquals actual="newDocFragmentType" expected="11" ignoreCase="false" id="type"/> |
| <nodeValue obj="newDocFragment" var="newDocFragmentValue"/> |
| <assertNull actual="newDocFragmentValue" id="value"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreateelement.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreateelement"> |
| <metadata> |
| <title>documentCreateElement</title> |
| <creator>NIST</creator> |
| <description> |
| The "createElement(tagName)" method creates an Element |
| of the type specified. |
| Retrieve the entire DOM document and invoke its |
| "createElement(tagName)" method with tagName="address". |
| The method should create an instance of an Element node |
| whose tagName is "address". The NodeName, NodeType |
| and NodeValue are returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newElement" type="Element"/> |
| <var name="newElementName" type="DOMString"/> |
| <var name="newElementType" type="int"/> |
| <var name="newElementValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createElement obj="doc" var="newElement" tagName=""address""/> |
| <nodeName obj="newElement" var="newElementName"/> |
| <assertEquals actual="newElementName" expected=""address"" ignoreCase="false" id="name"/> |
| <nodeType obj="newElement" var="newElementType"/> |
| <assertEquals actual="newElementType" expected="1" ignoreCase="false" id="type"/> |
| <nodeValue obj="newElement" var="newElementValue"/> |
| <assertNull actual="newElementValue" id="valueInitiallyNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreateelementcasesensitive.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreateelementcasesensitive"> |
| <metadata> |
| <title>documentCreateElementCaseSensitive</title> |
| <creator>NIST</creator> |
| <description> |
| The tagName parameter in the "createElement(tagName)" |
| method is case-sensitive for XML documents. |
| Retrieve the entire DOM document and invoke its |
| "createElement(tagName)" method twice. Once for tagName |
| equal to "address" and once for tagName equal to "ADDRESS" |
| Each call should create a distinct Element node. The |
| newly created Elements are then assigned attributes |
| that are retrieved. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newElement1" type="Element"/> |
| <var name="newElement2" type="Element"/> |
| <var name="attribute1" type="DOMString"/> |
| <var name="attribute2" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createElement obj="doc" var="newElement1" tagName=""ADDRESS""/> |
| <createElement obj="doc" var="newElement2" tagName=""address""/> |
| <setAttribute obj="newElement1" name=""district"" value=""Fort Worth""/> |
| <setAttribute obj="newElement2" name=""county"" value=""Dallas""/> |
| <getAttribute obj="newElement1" var="attribute1" name=""district""/> |
| <getAttribute obj="newElement2" var="attribute2" name=""county""/> |
| <assertEquals actual="attribute1" expected='"Fort Worth"' ignoreCase="false" id="attrib1"/> |
| <assertEquals actual="attribute2" expected='"Dallas"' ignoreCase="false" id="attrib2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreateelementdefaultattr.xml.kfail |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreateelementdefaultattr"> |
| <metadata> |
| <title>documentCreateElementDefaultAttr</title> |
| <creator>NIST</creator> |
| <description> |
| The "createElement(tagName)" method creates an Element |
| of the type specified. In addition, if there are known attributes |
| with default values, Attr nodes representing them are automatically |
| created and attached to the element. |
| Retrieve the entire DOM document and invoke its |
| "createElement(tagName)" method with tagName="address". |
| The method should create an instance of an Element node |
| whose tagName is "address". The tagName "address" has an |
| attribute with default values, therefore the newly created element |
| will have them. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newElement" type="Element"/> |
| <var name="defaultAttr" type="NamedNodeMap"/> |
| <var name="child" type="Node"/> |
| <var name="name" type="DOMString"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createElement obj="doc" var="newElement" tagName=""address""/> |
| <attributes obj="newElement" var="defaultAttr"/> |
| <item obj="defaultAttr" var="child" index="0" interface="NamedNodeMap"/> |
| <assertNotNull actual="child" id="defaultAttrNotNull"/> |
| <nodeName obj="child" var="name"/> |
| <assertEquals actual="name" expected=""street"" id="attrName" ignoreCase="false"/> |
| <nodeValue obj="child" var="value"/> |
| <assertEquals actual="value" expected=""Yes"" id="attrValue" ignoreCase="false"/> |
| <assertSize collection="defaultAttr" size="1" id="attrCount"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreateentityreference.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreateentityreference"> |
| <metadata> |
| <title>documentCreateEntityReference</title> |
| <creator>NIST</creator> |
| <description> |
| The "createEntityReference(name)" method creates an |
| EntityReferrence node. |
| Retrieve the entire DOM document and invoke its |
| "createEntityReference(name)" method. It should create |
| a new EntityReference node for the Entity with the |
| given name. The name, value and type are retrieved and |
| output. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-392B75AE"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newEntRefNode" type="EntityReference"/> |
| <var name="entRefValue" type="DOMString"/> |
| <var name="entRefName" type="DOMString"/> |
| <var name="entRefType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference obj="doc" var="newEntRefNode" name=""ent1""/> |
| <assertNotNull actual="newEntRefNode" id="createdEntRefNotNull"/> |
| <nodeValue obj="newEntRefNode" var="entRefValue"/> |
| <assertNull actual="entRefValue" id="value"/> |
| <nodeName obj="newEntRefNode" var="entRefName"/> |
| <assertEquals actual="entRefName" expected=""ent1"" ignoreCase="false" id="name"/> |
| <nodeType obj="newEntRefNode" var="entRefType"/> |
| <assertEquals actual="entRefType" expected="5" ignoreCase="false" id="type"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreateentityreferenceknown.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreateentityreferenceknown"> |
| <metadata> |
| <title>documentCreateEntityReferenceKnown</title> |
| <creator>NIST</creator> |
| <description> |
| The "createEntityReference(name)" method creates an |
| EntityReference node. In addition, if the referenced entity |
| is known, the child list of the "EntityReference" node |
| is the same as the corresponding "Entity" node. |
| Retrieve the entire DOM document and invoke its |
| "createEntityReference(name)" method. It should create |
| a new EntityReference node for the Entity with the |
| given name. The referenced entity is known, therefore the child |
| list of the "EntityReference" node is the same as the corresponding |
| "Entity" node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-392B75AE"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newEntRefNode" type="EntityReference"/> |
| <var name="newEntRefList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="name" type="DOMString"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference obj="doc" var="newEntRefNode" name=""ent3""/> |
| <assertNotNull actual="newEntRefNode" id="createdEntRefNotNull"/> |
| <childNodes obj="newEntRefNode" var="newEntRefList"/> |
| <assertSize collection="newEntRefList" size="1" id="size"/> |
| <firstChild interface="Node" obj="newEntRefNode" var="child"/> |
| <nodeName obj="child" var="name"/> |
| <assertEquals actual="name" expected=""#text"" ignoreCase="false" id="name"/> |
| <nodeValue obj="child" var="value"/> |
| <assertEquals actual="value" expected=""Texas"" ignoreCase="false" id="value"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreateprocessinginstruction.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreateprocessinginstruction"> |
| <metadata> |
| <title>documentCreateProcessingInstruction</title> |
| <creator>NIST</creator> |
| <description> |
| The "createProcessingInstruction(target,data)" method |
| creates a new ProcessingInstruction node with the |
| specified name and data string. |
| Retrieve the entire DOM document and invoke its |
| "createProcessingInstruction(target,data)" method. |
| It should create a new PI node with the specified target |
| and data. The target, data and type are retrieved and |
| output. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2001Apr/0020.html"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-135944439"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newPINode" type="ProcessingInstruction"/> |
| <var name="piValue" type="DOMString"/> |
| <var name="piName" type="DOMString"/> |
| <var name="piType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createProcessingInstruction obj="doc" var="newPINode" target=""TESTPI"" data=""This is a new PI node""/> |
| <assertNotNull actual="newPINode" id="createdPINotNull"/> |
| <nodeName obj="newPINode" var="piName"/> |
| <assertEquals actual="piName" expected=""TESTPI"" ignoreCase="false" id="name"/> |
| <nodeValue obj="newPINode" var="piValue"/> |
| <assertEquals actual="piValue" expected=""This is a new PI node"" ignoreCase="false" id="value"/> |
| <nodeType obj="newPINode" var="piType"/> |
| <assertEquals actual="piType" expected="7" ignoreCase="false" id="type"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentcreatetextnode.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentcreatetextnode"> |
| <metadata> |
| <title>documentCreateTextNode</title> |
| <creator>NIST</creator> |
| <description> |
| The "createTextNode(data)" method creates a Text node |
| given the specfied string. |
| Retrieve the entire DOM document and invoke its |
| "createTextNode(data)" method. It should create a |
| new Text node whose "data" is the specified string. |
| The NodeName and NodeType are also checked. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1975348127"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newTextNode" type="Text"/> |
| <var name="newTextName" type="DOMString"/> |
| <var name="newTextValue" type="DOMString"/> |
| <var name="newTextType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createTextNode obj="doc" var="newTextNode" data=""This is a new Text node""/> |
| <nodeValue obj="newTextNode" var="newTextValue"/> |
| <assertEquals actual="newTextValue" expected=""This is a new Text node"" ignoreCase="false" id="value"/> |
| <nodeName obj="newTextNode" var="newTextName"/> |
| <assertEquals actual="newTextName" expected=""#text"" ignoreCase="false" id="name"/> |
| <nodeType obj="newTextNode" var="newTextType"/> |
| <assertEquals actual="newTextType" expected="3" ignoreCase="false" id="type"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentgetdoctype.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentgetdoctype"> |
| <metadata> |
| <title>documentGetDocType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getDoctype()" method returns the Document |
| Type Declaration associated with this document. |
| Retrieve the entire DOM document and invoke its |
| "getDoctype()" method. The name of the document |
| type should be returned. The "getName()" method |
| should be equal to "staff" or "svg". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A31"/> |
| <!-- Node.nodeValue --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="docTypeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <name interface="DocumentType" obj="docType" var="docTypeName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="docTypeName" expected='"svg"' id="doctypeNameSVG" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="docTypeName" expected='"staff"' id="doctypeName" ignoreCase="false"/> |
| </else> |
| </if> |
| <nodeValue obj="docType" var="nodeValue"/> |
| <assertNull actual="nodeValue" id="initiallyNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentgetdoctypenodtd.xml |
|---|
| 0,0 → 1,34 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentgetdoctypenodtd"> |
| <metadata> |
| <title>documentGetDocTypeNoDTD</title> |
| <creator>NIST</creator> |
| <description> |
| The "getDoctype()" method returns null for XML documents |
| without a document type declaration. |
| Retrieve the XML document without a DTD and invoke the |
| "getDoctype()" method. It should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A31"/> |
| </metadata> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <load var="doc" href="hc_nodtdstaff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNull actual="docType" id="documentGetDocTypeNoDTDAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentgetelementsbytagnamelength.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentgetelementsbytagnamelength"> |
| <metadata> |
| <title>documentGetElementsByTagNameLength</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagName(tagName)" method returns a |
| NodeList of all the Elements with a given tagName. |
| Retrieve the entire DOM document and invoke its |
| "getElementsByTagName(tagName)" method with tagName |
| equal to "name". The method should return a NodeList |
| that contains 5 elements. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-A6C9094"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nameList" tagname=""name""/> |
| <assertSize collection="nameList" size="5" id="documentGetElementsByTagNameLengthAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentgetelementsbytagnametotallength.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentgetelementsbytagnametotallength"> |
| <metadata> |
| <title>documentGetElementsByTagNameTotalLength</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the entire DOM document, invoke |
| getElementsByTagName("*") and check the length of the NodeList. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-A6C9094"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nameList" tagname='"*"'/> |
| <if><contentType type="image/svg+xml"/> |
| <assertSize collection="nameList" size="39" id="elementCountSVG"/> |
| <else> |
| <assertSize collection="nameList" size="37" id="documentGetElementsByTagNameTotalLengthAssert"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentgetelementsbytagnamevalue.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentgetelementsbytagnamevalue"> |
| <metadata> |
| <title>documentGetElementsByTagNameValue</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagName(tagName)" method returns a |
| NodeList of all the Elements with a given tagName |
| in a pre-order traversal of the tree. |
| Retrieve the entire DOM document and invoke its |
| "getElementsByTagName(tagName)" method with tagName |
| equal to "name". The method should return a NodeList |
| that contains 5 elements. The FOURTH item in the |
| list is retrieved and output. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-A6C9094"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nameList" tagname=""name""/> |
| <item interface="NodeList" obj="nameList" var="nameNode" index="3"/> |
| <firstChild interface="Node" obj="nameNode" var="firstChild"/> |
| <nodeValue obj="firstChild" var="childValue"/> |
| <assertEquals actual="childValue" expected=""Jeny Oconnor"" id="documentGetElementsByTagNameValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentgetimplementation.xml.kfail |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentgetimplementation"> |
| <metadata> |
| <title>documentGetImplementation</title> |
| <creator>NIST</creator> |
| <description> |
| The "getImplementation()" method returns the |
| DOMImplementation object that handles this document. |
| Retrieve the entire DOM document and invoke its |
| "getImplementation()" method. It should return a |
| DOMImplementation whose "hasFeature("XML","1.0") |
| method returns the boolean value "true". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1B793EBA"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docImpl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <implementation obj="doc" var="docImpl"/> |
| <hasFeature obj="docImpl" var="state" feature=""XML"" version=""1.0""/> |
| <assertTrue actual="state" id="documentGetImplementationAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentgetrootnode.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentgetrootnode"> |
| <metadata> |
| <title>documentGetRootNode</title> |
| <creator>NIST</creator> |
| <description> |
| The "getDocumentElement()" method provides direct access |
| to the child node that is the root element of the document. |
| Retrieve the entire DOM document and invoke its |
| "getDocumentElement()" method. It should return an |
| Element node whose NodeName is "staff" (or "svg"). |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--documentElement attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-87CD092"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=251"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="root" type="Element"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <nodeName obj="root" var="rootName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="rootName" expected='"svg"' id="svgRootNode" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="rootName" expected='"staff"' id="documentGetRootNodeAssert" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentinvalidcharacterexceptioncreateattribute.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentinvalidcharacterexceptioncreateattribute"> |
| <metadata> |
| <title>documentInvalidCharacterExceptionCreateAttribute</title> |
| <creator>NIST</creator> |
| <description> |
| The "createAttribute(tagName)" method raises an |
| INVALID_CHARACTER_ERR DOMException if the specified |
| tagName contains an invalid character. |
| Retrieve the entire DOM document and invoke its |
| "createAttribute(tagName)" method with the tagName equal |
| to the string "invalid^Name". Due to the invalid |
| character the desired EXCEPTION should be raised. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1084891198"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1084891198')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1084891198"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="createdAttr" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createAttribute var="createdAttr" obj="doc" name=""invalid^Name""/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentinvalidcharacterexceptioncreateelement.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentinvalidcharacterexceptioncreateelement"> |
| <metadata> |
| <title>documentInvalidCharacterExceptionCreateElement</title> |
| <creator>NIST</creator> |
| <description> |
| The "createElement(tagName)" method raises an |
| INVALID_CHARACTER_ERR DOMException if the specified |
| tagName contains an invalid character. |
| Retrieve the entire DOM document and invoke its |
| "createElement(tagName)" method with the tagName equal |
| to the string "invalid^Name". Due to the invalid |
| character the desired EXCEPTION should be raised. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-2141741547')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="badElement" type="Element"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createElement var="badElement" obj="doc" tagName=""invalid^Name""/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentinvalidcharacterexceptioncreateentref.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentinvalidcharacterexceptioncreateentref"> |
| <metadata> |
| <title>documentInvalidCharacterExceptionCreateEntRef</title> |
| <creator>NIST</creator> |
| <description> |
| The "createEntityReference(tagName)" method raises an |
| INVALID_CHARACTER_ERR DOMException if the specified |
| tagName contains an invalid character. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-392B75AE"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-392B75AE')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="badEntityRef" type="EntityReference"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <if><contentType type="text/html"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createEntityReference var="badEntityRef" obj="doc" name='"foo"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <else> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createEntityReference var="badEntityRef" obj="doc" name=""invalid^Name""/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentinvalidcharacterexceptioncreateentref1.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentinvalidcharacterexceptioncreateentref1"> |
| <metadata> |
| <title>documentinvalidcharacterexceptioncreateentref1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Creating an entity reference with an empty name should cause an INVALID_CHARACTER_ERR. |
| </description> |
| <date qualifier="created">2004-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-392B75AE"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-392B75AE')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=525"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="badEntityRef" type="EntityReference"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <if><contentType type="text/html"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createEntityReference var="badEntityRef" obj="doc" name='"foo"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <else> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createEntityReference var="badEntityRef" obj="doc" name='""'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentinvalidcharacterexceptioncreatepi.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentinvalidcharacterexceptioncreatepi"> |
| <metadata> |
| <title>documentInvalidCharacterExceptionCreatePI</title> |
| <creator>NIST</creator> |
| <description> |
| The "createProcessingInstruction(target,data) method |
| raises an INVALID_CHARACTER_ERR DOMException if the |
| specified tagName contains an invalid character. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-135944439"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-135944439')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="badPI" type="ProcessingInstruction"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <if><contentType type="text/html"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createProcessingInstruction var="badPI" obj="doc" target='"foo"' data='"data"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <else> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createProcessingInstruction var="badPI" obj="doc" target=""invalid^Name"" data=""data""/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documentinvalidcharacterexceptioncreatepi1.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documentinvalidcharacterexceptioncreatepi1"> |
| <metadata> |
| <title>documentinvalidcharacterexceptioncreatepi1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Creating a processing instruction with an empty target should cause an INVALID_CHARACTER_ERR. |
| </description> |
| <date qualifier="created">2004-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-135944439"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-135944439')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=525"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="badPI" type="ProcessingInstruction"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <if><contentType type="text/html"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createProcessingInstruction var="badPI" obj="doc" target='"foo"' data='"data"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <else> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createProcessingInstruction var="badPI" obj="doc" target='""' data=""data""/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documenttypegetdoctype.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documenttypegetdoctype"> |
| <metadata> |
| <title>documenttypeGetDocType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getName()" method contains the name of the DTD. |
| Retrieve the Document Type for this document and examine |
| the string returned by the "getName()" method. |
| It should be set to "staff". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A31"/> |
| <!--name attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1844763134"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="name" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <name interface="DocumentType" obj="docType" var="name"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="name" expected='"svg"' id="doctypeName" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="name" expected='"staff"' id="documenttypeGetDocTypeAssert" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documenttypegetentities.xml.kfail |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documenttypegetentities"> |
| <metadata> |
| <title>documenttypeGetEntities</title> |
| <creator>NIST</creator> |
| <description> |
| The "getEntities()" method is a NamedNodeMap that contains |
| the general entities for this document. |
| Retrieve the Document Type for this document and create |
| a NamedNodeMap of all its entities. The entire map is |
| traversed and the names of the entities are retrieved. |
| There should be 5 entities. Duplicates should be ignored. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1788794630"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entityList" type="NamedNodeMap"/> |
| <var name="name" type="DOMString"/> |
| <var name="expectedResult" type="Collection"> |
| <member>"ent1"</member> |
| <member>"ent2"</member> |
| <member>"ent3"</member> |
| <member>"ent4"</member> |
| <member>"ent5"</member> |
| </var> |
| <var name="expectedResultSVG" type="Collection"> |
| <member>"ent1"</member> |
| <member>"ent2"</member> |
| <member>"ent3"</member> |
| <member>"ent4"</member> |
| <member>"ent5"</member> |
| <member>"svgunit"</member> |
| <member>"svgtest"</member> |
| </var> |
| <var name="nameList" type="Collection"/> |
| <var name="entity" type="Node"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entityList"/> |
| <assertNotNull actual="entityList" id="entitiesNotNull"/> |
| <for-each collection="entityList" member="entity"> |
| <nodeName obj="entity" var="name"/> |
| <append collection="nameList" item="name"/> |
| </for-each> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="nameList" expected="expectedResultSVG" id="entityNamesSVG" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="nameList" expected="expectedResult" id="entityNames" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documenttypegetentitieslength.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documenttypegetentitieslength"> |
| <metadata> |
| <title>documenttypeGetEntitiesLength</title> |
| <creator>NIST</creator> |
| <description> |
| Duplicate entities are to be discarded. |
| Retrieve the Document Type for this document and create |
| a NamedNodeMap of all its entities. The entity named |
| "ent1" is defined twice and therefore that last |
| occurrance should be discarded. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1788794630"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entityList" type="NamedNodeMap"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entityList"/> |
| <assertNotNull actual="entityList" id="entitiesNotNull"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertSize collection="entityList" size="7" id="entitySizeSVG"/> |
| <else> |
| <assertSize collection="entityList" size="5" id="entitySize"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documenttypegetentitiestype.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documenttypegetentitiestype"> |
| <metadata> |
| <title>documenttypeGetEntitiesType</title> |
| <creator>NIST</creator> |
| <description> |
| Every node in the map returned by the "getEntities()" |
| method implements the Entity interface. |
| Retrieve the Document Type for this document and create |
| a NamedNodeMap of all its entities. Traverse the |
| entire list and examine the NodeType of each node |
| in the list. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1788794630"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entityList" type="NamedNodeMap"/> |
| <var name="entity" type="Node"/> |
| <var name="entityType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entityList"/> |
| <assertNotNull actual="entityList" id="entitiesNotNull"/> |
| <for-each collection="entityList" member="entity"> |
| <nodeType obj="entity" var="entityType"/> |
| <assertEquals actual="entityType" expected="6" id="documenttypeGetEntitiesTypeAssert" ignoreCase="false"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documenttypegetnotations.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documenttypegetnotations"> |
| <metadata> |
| <title>documenttypeGetNotations</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNotations()" method creates a NamedNodeMap that |
| contains all the notations declared in the DTD. |
| Retrieve the Document Type for this document and create |
| a NamedNodeMap object of all the notations. There |
| should be two items in the list (notation1 and notation2). |
| </description> |
| <contributor>Mary Brady</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D46829EF"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notationList" type="NamedNodeMap"/> |
| <var name="notation" type="Node"/> |
| <var name="notationName" type="DOMString"/> |
| <var name="actual" type="Collection"/> |
| <var name="expected" type="Collection"> |
| <member>"notation1"</member> |
| <member>"notation2"</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notationList"/> |
| <assertNotNull actual="notationList" id="notationsNotNull"/> |
| <for-each collection="notationList" member="notation"> |
| <nodeName obj="notation" var="notationName"/> |
| <append collection="actual" item="notationName"/> |
| </for-each> |
| <assertEquals actual="actual" expected="expected" id="names" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/documenttypegetnotationstype.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="documenttypegetnotationstype"> |
| <metadata> |
| <title>documenttypeGetNotationsType</title> |
| <creator>NIST</creator> |
| <description> |
| Every node in the map returned by the "getNotations()" |
| method implements the Notation interface. |
| Retrieve the Document Type for this document and create |
| a NamedNodeMap object of all the notations. Traverse |
| the entire list and examine the NodeType of each node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D46829EF"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notationList" type="NamedNodeMap"/> |
| <var name="notation" type="Node"/> |
| <var name="notationType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notationList"/> |
| <assertNotNull actual="notationList" id="notationsNotNull"/> |
| <for-each collection="notationList" member="notation"> |
| <nodeType obj="notation" var="notationType"/> |
| <assertEquals actual="notationType" expected="12" id="documenttypeGetNotationsTypeAssert" ignoreCase="false"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/domimplementationfeaturenoversion.xml.kfail |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="domimplementationfeaturenoversion"> |
| <metadata> |
| <title>domimplementationFeatureNoVersion</title> |
| <creator>NIST</creator> |
| <description> |
| hasFeature("XML", "") should return true for implementations that can read staff files. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-5CED94D7"/> |
| <subject resource="http://www.w3.org/2000/11/DOM-Level-2-errata#core-14"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <hasFeature obj="domImpl" var="state" feature='"XML"' version='""'/> |
| <assertTrue actual="state" id="hasXMLEmpty"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/domimplementationfeaturenull.xml.kfail |
|---|
| 0,0 → 1,35 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="domimplementationfeaturenull"> |
| <metadata> |
| <title>domimplementationFeatureNull</title> |
| <creator>NIST</creator> |
| <description> |
| hasFeature("XML", null) should return true for implementations that can read staff documents. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2001-08-23</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-5CED94D7"/> |
| <subject resource="http://www.w3.org/2000/11/DOM-Level-2-errata#core-14"/> |
| </metadata> |
| <implementationAttribute name="hasNullString" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <hasFeature obj="domImpl" var="state" feature='"XML"' version="nullVersion"/> |
| <assertTrue actual="state" id="hasXMLnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/domimplementationfeaturexml.xml.kfail |
|---|
| 0,0 → 1,32 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="domimplementationfeaturexml"> |
| <metadata> |
| <title>domimplementationFeaturexml</title> |
| <creator>NIST</creator> |
| <description> |
| hasFeature("xml", "1.0") should return true for implementations that can read staff documents. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-5CED94D7"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <hasFeature obj="domImpl" var="state" feature='"xml"' version='"1.0"'/> |
| <assertTrue actual="state" id="hasXML1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementaddnewattribute.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementaddnewattribute"> |
| <metadata> |
| <title>elementAddNewAttribute</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttribute(name,value)" method adds a new attribute |
| to the Element |
| Retrieve the last child of the last employee, then |
| add an attribute to it by invoking the |
| "setAttribute(name,value)" method. It should create |
| a "name" attribute with an assigned value equal to |
| "value". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--setAttribute--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="4" var="testEmployee"/> |
| <setAttribute obj="testEmployee" name=""district"" value=""dallas""/> |
| <getAttribute obj="testEmployee" var="attrValue" name=""district""/> |
| <assertEquals actual="attrValue" expected=""dallas"" id="elementAddNewAttributeAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementassociatedattribute.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementassociatedattribute"> |
| <metadata> |
| <title>elementAssociatedAttribute</title> |
| <creator>NIST</creator> |
| <description> |
| Elements may have attributes associated with them. |
| Retrieve the first attribute from the last child of |
| the first employee and invoke the "getSpecified()" |
| method. This test is only intended to show that |
| Elements can actually have attributes. This test uses |
| the "getNamedItem(name)" method from the NamedNodeMap |
| interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="specified" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"address"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name='"domestic"'/> |
| <specified obj="domesticAttr" var="specified"/> |
| <assertTrue actual="specified" id="domesticSpecified"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementchangeattributevalue.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementchangeattributevalue"> |
| <metadata> |
| <title>elementChangeAttributeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttribute(name,value)" method adds a new attribute |
| to the Element. If the "name" is already present, then |
| its value should be changed to the new one that is in |
| the "value" parameter. |
| Retrieve the last child of the fourth employee, then add |
| an attribute to it by invoking the |
| "setAttribute(name,value)" method. Since the name of the |
| used attribute("street") is already present in this |
| element, then its value should be changed to the new one |
| of the "value" parameter. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--setAttribute--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="3" var="testEmployee"/> |
| <setAttribute obj="testEmployee" name=""street"" value=""Neither""/> |
| <getAttribute obj="testEmployee" var="attrValue" name=""street""/> |
| <assertEquals actual="attrValue" expected=""Neither"" id="elementChangeAttributeValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementcreatenewattribute.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementcreatenewattribute"> |
| <metadata> |
| <title>elementCreateNewAttribute</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method adds a new |
| attribute to the Element. |
| Retrieve first address element and add |
| a new attribute node to it by invoking its |
| "setAttributeNode(newAttr)" method. This test makes use |
| of the "createAttribute(name)" method from the Document |
| interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--setAttributeNode--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="oldAttr" type="Attr"/> |
| <var name="districtAttr" type="Attr"/> |
| <var name="attrVal" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddress"/> |
| <createAttribute obj="doc" var="newAttribute" name=""district""/> |
| <setAttributeNode obj="testAddress" var="oldAttr" newAttr="newAttribute"/> |
| <assertNull actual="oldAttr" id="old_attr_doesnt_exist"/> |
| <getAttributeNode obj="testAddress" var="districtAttr" name=""district""/> |
| <assertNotNull actual="districtAttr" id="new_district_accessible"/> |
| <getAttribute var="attrVal" obj="testAddress" name=""district""/> |
| <assertEquals actual="attrVal" expected="""" id="attr_value" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementgetattributenode.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementgetattributenode"> |
| <metadata> |
| <title>elementGetAttributeNode</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributeNode(name)" method retrieves an |
| attribute node by name. |
| Retrieve the attribute "domestic" from the last child |
| of the first employee. Since the method returns an |
| Attr object, the "name" can be examined to ensure the |
| proper attribute was retrieved. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-217A91B8"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="name" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <getAttributeNode obj="testEmployee" var="domesticAttr" name=""domestic""/> |
| <nodeName obj="domesticAttr" var="name"/> |
| <assertEquals actual="name" expected=""domestic"" id="elementGetAttributeNodeAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementgetattributenodenull.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementgetattributenodenull"> |
| <metadata> |
| <title>elementGetAttributeNodeNull</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributeNode(name)" method retrieves an |
| attribute node by name. It should return null if the |
| "name" attribute does not exist. |
| Retrieve the last child of the first employee and attempt |
| to retrieve a non-existing attribute. The method should |
| return "null". The non-existing attribute to be used |
| is "invalidAttribute". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-217A91B8"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="domesticAttr" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <getAttributeNode obj="testEmployee" var="domesticAttr" name=""invalidAttribute""/> |
| <assertNull actual="domesticAttr" id="elementGetAttributeNodeNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementgetelementempty.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementgetelementempty"> |
| <metadata> |
| <title>elementGetElementEmpty</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttribute(name)" method returns an empty |
| string if no value was assigned to an attribute and |
| no default value was given in the DTD file. |
| Retrieve the last child of the last employee, then |
| invoke "getAttribute(name)" method, where "name" is an |
| attribute without a specified or DTD default value. |
| The "getAttribute(name)" method should return the empty |
| string. This method makes use of the |
| "createAttribute(newAttr)" method from the Document |
| interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--getAttribute--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-666EE0F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createAttribute obj="doc" var="newAttribute" name=""district""/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="3" var="testEmployee"/> |
| <setAttributeNode obj="testEmployee" var="domesticAttr" newAttr="newAttribute"/> |
| <getAttribute obj="testEmployee" var="attrValue" name=""district""/> |
| <assertEquals actual="attrValue" expected="""" id="elementGetElementEmptyAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementgetelementsbytagname.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementgetelementsbytagname"> |
| <metadata> |
| <title>elementGetElementsByTagName</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagName(name)" method returns a list |
| of all descendant Elements with the given tag name. |
| Test for an empty list. |
| Create a NodeList of all the descendant elements |
| using the string "noMatch" as the tagName. |
| The method should return a NodeList whose length is |
| "0" since there are not any descendant elements |
| that match the given tag name. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--getElementsByTagName--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1938918D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <assertSize collection="elementList" size="5" id="elementGetElementsByTagNameAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementgetelementsbytagnameaccessnodelist.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementgetelementsbytagnameaccessnodelist"> |
| <metadata> |
| <title>elementgetelementsbytagnameaccessnodelist</title> |
| <creator>NIST</creator> |
| <description> |
| Element.getElementsByTagName("employee") should return a NodeList whose length is |
| "5" in the order the children were encountered. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--getElementsByTagName--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1938918D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="childType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="3" var="testEmployee"/> |
| <!-- first element might be text --> |
| <firstChild interface="Node" obj="testEmployee" var="child"/> |
| <nodeType var="childType" obj="child"/> |
| <if><equals actual="childType" expected="3" ignoreCase="false"/> |
| <nextSibling var="child" obj="child" interface="Node"/> |
| </if> |
| <nodeName var="childName" obj="child" interface="Node"/> |
| <assertEquals actual="childName" expected='"employeeId"' id="nodename" ignoreCase="false"/> |
| <firstChild var="child" obj="child" interface="Node"/> |
| <nodeValue var="childValue" obj="child"/> |
| <assertEquals actual="childValue" expected='"EMP0004"' ignoreCase="false" id="emp0004"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementgetelementsbytagnamenomatch.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementgetelementsbytagnamenomatch"> |
| <metadata> |
| <title>elementGetElementsByTagName</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagName(name)" method returns a list |
| of all descendant Elements with the given tag name. |
| Create a NodeList of all the descendant elements |
| using the string "employee" as the tagName. |
| The method should return a NodeList whose length is |
| "5". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--getElementsByTagName--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1938918D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""noMatch"" var="elementList"/> |
| <assertSize collection="elementList" size="0" id="elementGetElementsByTagNameNoMatchNoMatchAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementgetelementsbytagnamespecialvalue.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementgetelementsbytagnamespecialvalue"> |
| <metadata> |
| <title>elementGetElementsByTagNamesSpecialValue</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagName(name)" method may use the |
| special value "*" to match all tags in the element |
| tree. |
| Create a NodeList of all the descendant elements |
| of the last employee by using the special value "*". |
| The method should return all the descendant children(6) |
| in the order the children were encountered. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1938918D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="lastEmployee" type="Element"/> |
| <var name="lastempList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="expectedResult" type="List"> |
| <member>"employeeId"</member> |
| <member>"name"</member> |
| <member>"position"</member> |
| <member>"salary"</member> |
| <member>"gender"</member> |
| <member>"address"</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="4" var="lastEmployee"/> |
| <getElementsByTagName interface="Element" obj="lastEmployee" var="lastempList" tagname=""*""/> |
| <for-each collection="lastempList" member="child"> |
| <nodeName obj="child" var="childName"/> |
| <append collection="result" item="childName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedResult" id="tagNames" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementgettagname.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementgettagname"> |
| <metadata> |
| <title>elementGetTagName</title> |
| <creator>NIST</creator> |
| <description> |
| The "getTagName()" method returns the |
| tagName of an element. |
| Invoke the "getTagName()" method one the |
| root node. The value returned should be "staff". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-104682815"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=251"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="root" type="Element"/> |
| <var name="tagname" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <tagName obj="root" var="tagname"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="tagname" expected='"svg"' id="svgTagName" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="tagname" expected='"staff"' id="elementGetTagNameAssert" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementinuseattributeerr.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementinuseattributeerr"> |
| <metadata> |
| <title>elementInUseAttributeErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method raises an |
| "INUSE_ATTRIBUTE_ERR DOMException if the "newAttr" |
| is already an attribute of another element. |
| Retrieve the last child of the second employee and append |
| a newly created element. The "createAttribute(name)" |
| and "setAttributeNode(newAttr)" methods are invoked |
| to create and add a new attribute to the newly created |
| Element. The "setAttributeNode(newAttr)" method is |
| once again called to add the new attribute causing an |
| exception to be raised since the attribute is already |
| an attribute of another element. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-887236154')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INUSE_ATTRIBUTE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="addressElementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <var name="newElement" type="Element"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="setAttr1" type="Attr"/> |
| <var name="setAttr2" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"address"' var="addressElementList"/> |
| <item interface="NodeList" obj="addressElementList" index="1" var="testAddress"/> |
| <createElement obj="doc" var="newElement" tagName='"newElement"'/> |
| <appendChild var="appendedChild" obj="testAddress" newChild="newElement"/> |
| <createAttribute obj="doc" var="newAttribute" name='"newAttribute"'/> |
| <setAttributeNode var="setAttr1" obj="newElement" newAttr="newAttribute"/> |
| <assertDOMException id="throw_INUSE_ATTRIBUTE_ERR"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setAttributeNode var="setAttr2" obj="testAddress" newAttr="newAttribute"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementinvalidcharacterexception.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementinvalidcharacterexception"> |
| <metadata> |
| <title>elementInvalidCharacterException</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttribute(name,value)" method raises an |
| "INVALID_CHARACTER_ERR DOMException if the specified |
| name contains an invalid character. |
| Retrieve the last child of the first employee and |
| call its "setAttribute(name,value)" method with |
| "name" containing an invalid character. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-F68F082')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddress"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <setAttribute obj="testAddress" name=""invalid^Name"" value=""value""/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementnormalize.xml.notimpl |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementnormalize"> |
| <metadata> |
| <title>elementNormalize</title> |
| <creator>NIST</creator> |
| <description> |
| The "normalize()" method puts all the nodes in the full |
| depth of the sub-tree underneath this element into a |
| "normal" form. |
| Retrieve the third employee and access its second child. |
| This child contains a block of text that is spread |
| across multiple lines. The content of the "name" child |
| should be parsed and treated as a single Text node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-162CF083"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="root" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testName" type="Element"/> |
| <var name="firstChild" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <documentElement obj="doc" var="root"/> |
| <normalize obj="root"/> |
| <getElementsByTagName interface="Element" obj="root" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testName"/> |
| <firstChild interface="Node" obj="testName" var="firstChild"/> |
| <nodeValue obj="firstChild" var="childValue"/> |
| <assertEquals actual="childValue" expected=""Roger\n Jones"" id="elementNormalizeAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementnotfounderr.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementnotfounderr"> |
| <metadata> |
| <title>elementNotFoundErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeAttributeNode(oldAttr)" method raises a |
| NOT_FOUND_ERR DOMException if the "oldAttr" attribute |
| is not an attribute of the element. |
| Retrieve the last employee and attempt to remove |
| a non existing attribute node. This should cause the |
| intended exception to be raised. This test makes use |
| of the "createAttribute(name)" method from the Document |
| interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-D589198')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="oldAttribute" type="Attr"/> |
| <var name="addressElementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <var name="attrAddress" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="addressElementList"/> |
| <item interface="NodeList" obj="addressElementList" index="4" var="testAddress"/> |
| <createAttribute obj="doc" var="oldAttribute" name=""oldAttribute""/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeAttributeNode obj="testAddress" oldAttr="oldAttribute" var="attrAddress"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementremoveattribute.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementremoveattribute"> |
| <metadata> |
| <title>elementRemoveAttribute</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeAttribute(name)" removes an attribute by name. |
| If the attribute has a default value, it is immediately |
| replaced. |
| Retrieve the attribute named "street" from the last child |
| of the fourth employee, then remove the "street" |
| attribute by invoking the "removeAttribute(name)" method. |
| The "street" attribute has a default value defined in the |
| DTD file, that value should immediately replace the old |
| value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D6AC0F9"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"address"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="3" var="testEmployee"/> |
| <removeAttribute obj="testEmployee" name='"street"'/> |
| <getAttribute obj="testEmployee" var="attrValue" name='"street"'/> |
| <assertEquals actual="attrValue" expected='"Yes"' id="streetYes" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementremoveattributeaftercreate.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementremoveattributeaftercreate"> |
| <metadata> |
| <title>elementRemoveAttributeAfterCreate</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeAttributeNode(oldAttr)" method removes the |
| specified attribute. |
| Retrieve the last child of the third employee, add a |
| new "district" node to it and then try to remove it. |
| To verify that the node was removed use the |
| "getNamedItem(name)" method from the NamedNodeMap |
| interface. It also uses the "getAttributes()" method |
| from the Node interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--removeAttributeNode--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="districtAttr" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <createAttribute obj="doc" var="newAttribute" name=""district""/> |
| <setAttributeNode obj="testEmployee" var="districtAttr" newAttr="newAttribute"/> |
| <removeAttributeNode obj="testEmployee" var="districtAttr" oldAttr="newAttribute"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItem obj="attributes" var="districtAttr" name=""district""/> |
| <assertNull actual="districtAttr" id="elementRemoveAttributeAfterCreateAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementremoveattributenode.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementremoveattributenode"> |
| <metadata> |
| <title>elementRemoveAttributeNode</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeAttributeNode(oldAttr)" method returns the |
| node that was removed. |
| Retrieve the last child of the third employee and |
| remove its "street" Attr node. The method should |
| return the old attribute node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="removedAttr" type="Attr"/> |
| <var name="removedValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <getAttributeNode obj="testEmployee" var="streetAttr" name=""street""/> |
| <removeAttributeNode obj="testEmployee" var="removedAttr" oldAttr="streetAttr"/> |
| <value interface="Attr" obj="removedAttr" var="removedValue"/> |
| <assertEquals actual="removedValue" expected=""No"" id="elementRemoveAttributeNodeAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementremoveattributenodenomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementremoveattributenodenomodificationallowederr"> |
| <metadata> |
| <title>elementRemoveAttributeNodeNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeAttributeNode(oldAttr)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Try to remove the "domestic" attribute |
| from the entity reference by executing the "removeAttributeNode(oldAttr)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-D589198')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="genList" type="NodeList"/> |
| <var name="gen" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="gList" type="NodeList"/> |
| <var name="genElement" type="Element"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <var name="attrNode" type="Attr"/> |
| <var name="removedAttr" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <childNodes obj="gender" var="genList"/> |
| <item interface="NodeList" obj="genList" var="gen" index="0"/> |
| <assertNotNull actual="gen" id="genNotNull"/> |
| <nodeType var="nodeType" obj="gen"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="gen" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="gen" id="createdEntRefNotNull"/> |
| </if> |
| <childNodes obj="gen" var="gList"/> |
| <item interface="NodeList" obj="gList" var="genElement" index="0"/> |
| <assertNotNull actual="genElement" id="genElementNotNull"/> |
| <attributes obj="genElement" var="attrList"/> |
| <getNamedItem obj="attrList" var="attrNode" name='"domestic"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeAttributeNode var="removedAttr" obj="genElement" oldAttr="attrNode"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementremoveattributenodenomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementremoveattributenodenomodificationallowederrEE"> |
| <metadata> |
| <title>elementRemoveAttributeNodeNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeAttributeNode(oldAttr)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Create an entity reference and add it to the children of the THIRD "gender" element. |
| Try to remove the "domestic" attribute from the entity |
| reference by executing the "removeAttributeNode(oldAttr)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-21</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-D589198')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/elementremoveattributenodenomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <var name="attrNode" type="Attr"/> |
| <var name="nodeType" type="int"/> |
| <var name="removedAttr" type="Attr"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <createEntityReference var="entRef" obj="doc" name=""ent4""/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <appendChild obj="gender" newChild="entRef" var="appendedChild"/> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <attributes obj="entElement" var="attrList"/> |
| <getNamedItem obj="attrList" var="attrNode" name='"domestic"'/> |
| <assertNotNull actual="attrNode" id="attrNodeNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeAttributeNode var="removedAttr" obj="entElement" oldAttr="attrNode"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementremoveattributenomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementremoveattributenomodificationallowederr"> |
| <metadata> |
| <title>elementRemoveAttributeNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeAttribute(name)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Try to remove the "domestic" attribute |
| from the entity reference by executing the "removeAttribute(name)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D6AC0F9"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6D6AC0F9')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D6AC0F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="genList" type="NodeList"/> |
| <var name="gen" type="Node"/> |
| <var name="gList" type="NodeList"/> |
| <var name="nodeType" type="int"/> |
| <var name="genElement" type="Element"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <childNodes obj="gender" var="genList"/> |
| <item interface="NodeList" obj="genList" var="gen" index="0"/> |
| <assertNotNull actual="gen" id="genNotNull"/> |
| <nodeType var="nodeType" obj="gen"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="gen" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="gen" id="createdEntRefNotNull"/> |
| </if> |
| <childNodes obj="gen" var="gList"/> |
| <item interface="NodeList" obj="gList" var="genElement" index="0"/> |
| <assertNotNull actual="genElement" id="genElementNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeAttribute obj="genElement" name='"domestic"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementremoveattributenomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementremoveattributenomodificationallowederrEE"> |
| <metadata> |
| <title>elementRemoveAttributeNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeAttribute(name)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Create an reference the entity ent4 and add it to the THIRD "gender" element. |
| Try to remove the "domestic" attribute from the entity reference by executing the "removeAttribute(name)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-21</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D6AC0F9"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6D6AC0F9')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D6AC0F9"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/elementremoveattributenomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname='"gender"'/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <createEntityReference obj="doc" var="entRef" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <appendChild obj="gender" newChild="entRef" var="appendedChild"/> |
| <firstChild obj="entRef" var="entElement" interface="Node"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeAttribute obj="entElement" name='"domestic"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementremoveattributerestoredefaultvalue.xml.kfail |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementremoveattributerestoredefaultvalue"> |
| <metadata> |
| <title>elementRemoveAttributeRestoreDefaultValue</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeAttributeNode(oldAttr)" method removes the |
| specified attribute node and restores any default values. |
| Retrieve the last child of the third employeed and |
| remove its "street" Attr node. Since this node has a |
| default value defined in the DTD file, that default |
| should immediately be the new value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--removeAttributeNode--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="attribute" type="DOMString"/> |
| <var name="removedAttr" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <getAttributeNode obj="testEmployee" var="streetAttr" name=""street""/> |
| <removeAttributeNode var="removedAttr" obj="testEmployee" oldAttr="streetAttr"/> |
| <getAttribute obj="testEmployee" var="attribute" name=""street""/> |
| <assertEquals actual="attribute" expected=""Yes"" id="streetYes" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementreplaceattributewithself.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementreplaceattributewithself"> |
| <metadata> |
| <title>elementReplaceAttributeWithSelf</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| This test calls setAttributeNode to replace an attribute with itself. |
| Since the node is not an attribute of another Element, it would |
| be inappropriate to throw an INUSE_ATTRIBUTE_ERR. |
| This test was derived from elementinuserattributeerr which |
| inadvertanly made this test. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2001-10-31</date> |
| <!--setAttributeNode--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="replacedAttr" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"address"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <getAttributeNode var="streetAttr" obj="testEmployee" name='"street"'/> |
| <setAttributeNode obj="testEmployee" var="replacedAttr" newAttr="streetAttr"/> |
| <assertSame actual="replacedAttr" expected="streetAttr" id="replacedAttr"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementreplaceexistingattribute.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementreplaceexistingattribute"> |
| <metadata> |
| <title>elementReplaceExistingAttribute</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method adds a new |
| attribute to the Element. If the "newAttr" Attr node is |
| already present in this element, it should replace the |
| existing one. |
| Retrieve the last child of the third employee and add a |
| new attribute node by invoking the "setAttributeNode(new |
| Attr)" method. The new attribute node to be added is |
| "street", which is already present in this element. The |
| method should replace the existing Attr node with the |
| new one. This test uses the "createAttribute(name)" |
| method from the Document interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="name" type="DOMString"/> |
| <var name="setAttr" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <createAttribute obj="doc" var="newAttribute" name=""street""/> |
| <setAttributeNode var="setAttr" obj="testEmployee" newAttr="newAttribute"/> |
| <getAttribute obj="testEmployee" var="name" name=""street""/> |
| <assertEquals actual="name" expected="""" id="elementReplaceExistingAttributeAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementreplaceexistingattributegevalue.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementreplaceexistingattributegevalue"> |
| <metadata> |
| <title>elementReplaceExistingAttributeGeValue</title> |
| <creator>NIST</creator> |
| <description> |
| If the "setAttributeNode(newAttr)" method replaces an |
| existing Attr node with the same name, then it should |
| return the previously existing Attr node. |
| Retrieve the last child of the third employee and add a |
| new attribute node. The new attribute node is "street", |
| which is already present in this Element. The method |
| should return the existing Attr node(old "street" Attr). |
| This test uses the "createAttribute(name)" method |
| from the Document interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--setAttributeNode--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <createAttribute obj="doc" var="newAttribute" name=""street""/> |
| <setAttributeNode obj="testEmployee" var="streetAttr" newAttr="newAttribute"/> |
| <value interface="Attr" obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected=""No"" id="streetNo" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementretrieveallattributes.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementretrieveallattributes"> |
| <metadata> |
| <title>elementRetrieveAllAttributes</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method(Node Interface) may |
| be used to retrieve the set of all attributes of an |
| element. |
| Create a list of all the attributes of the last child |
| of the first employee by using the "getAttributes()" |
| method. Examine the length of the attribute list. |
| This test uses the "getLength()" method from the |
| NameNodeMap interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="addressList"/> |
| <item interface="NodeList" obj="addressList" index="0" var="testAddress"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <assertSize collection="attributes" size="2" id="elementRetrieveAllAttributesAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementretrieveattrvalue.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementretrieveattrvalue"> |
| <metadata> |
| <title>elementRetrieveAttrValue</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttribute(name)" method returns an attribute |
| value by name. |
| Retrieve the second address element, then |
| invoke the 'getAttribute("street")' method. This should |
| return the value of the attribute("No"). |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--getAttribute--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-666EE0F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testAddress"/> |
| <getAttribute obj="testAddress" var="attrValue" name=""street""/> |
| <assertEquals actual="attrValue" expected=""No"" id="attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementretrievetagname.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementretrievetagname"> |
| <metadata> |
| <title>elementRetrieveTagName</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagName()" method returns a NodeList |
| of all descendant elements with a given tagName. |
| Invoke the "getElementsByTagName()" method and create |
| a NodeList of "position" elements. Retrieve the second |
| "position" element in the list and return the NodeName. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--nodeName attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <!--tagName attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-104682815"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="name" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""position"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="testEmployee"/> |
| <nodeName obj="testEmployee" var="name"/> |
| <assertEquals actual="name" expected=""position"" id="nodename" ignoreCase="false"/> |
| <tagName obj="testEmployee" var="name"/> |
| <assertEquals actual="name" expected=""position"" id="tagname" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementsetattributenodenomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementsetattributenodenomodificationallowederr"> |
| <metadata> |
| <title>elementSetAttributeNodeNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Try to remove the "domestic" attribute |
| from the entity reference by executing the "setAttributeNode(newAttr)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-887236154')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="entRef" type="Node"/> |
| <var name="entElement" type="Element"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="nodeType" type="int"/> |
| <var name="badAttr" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <firstChild interface="Node" var="entRef" obj="gender"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <nodeType var="nodeType" obj="entRef"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <createAttribute obj="doc" var="newAttr" name='"newAttr"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setAttributeNode var="badAttr" obj="entElement" newAttr="newAttr"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementsetattributenodenomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementsetattributenodenomodificationallowederrEE"> |
| <metadata> |
| <title>elementsetattributenodenomodificationallowederree</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Create an entity reference and add to the THIRD "gender" element. The elements |
| content is an entity reference. Try to remove the "domestic" attribute |
| from the entity reference by executing the "setAttributeNode(newAttr)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-21</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-887236154')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/elementsetattributenodenomodificationallowederr.xml"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="badAttr" type="Attr"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <appendChild obj="gender" newChild="entRef" var="appendedChild"/> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <createAttribute obj="doc" var="newAttr" name='"newAttr"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setAttributeNode var="badAttr" obj="entElement" newAttr="newAttr"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementsetattributenodenull.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementsetattributenodenull"> |
| <metadata> |
| <title>elementSetAttributeNodeNull</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method returns the |
| null value if no previously existing Attr node with the |
| same name was replaced. |
| Retrieve the last child of the third employee and add a |
| new attribute to it. The new attribute node added is |
| "district", which is not part of this Element. The |
| method should return the null value. |
| This test uses the "createAttribute(name)" |
| method from the Document interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="districtAttr" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <createAttribute obj="doc" var="newAttribute" name=""district""/> |
| <setAttributeNode obj="testEmployee" var="districtAttr" newAttr="newAttribute"/> |
| <assertNull actual="districtAttr" id="elementSetAttributeNodeNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementsetattributenomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementsetattributenomodificationallowederr"> |
| <metadata> |
| <title>elementSetAttributeNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttribute(name,value)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Try to remove the "domestic" attribute |
| from the entity reference by executing the "setAttribute(name,value)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-F68F082')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <firstChild interface="Node" var="entRef" obj="gender"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setAttribute obj="entElement" name='"newAttr"' value='"newValue"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementsetattributenomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementsetattributenomodificationallowederrEE"> |
| <metadata> |
| <title>elementSetAttributeNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setAttribute(name,value)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Add an ent4 reference to the children of the THIRD "gender" element. |
| Try to remove the "domestic" attribute |
| from the entity reference by executing the "setAttribute(name,value)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-21</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-F68F082')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/elementsetattributenomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <createEntityReference var="entRef" obj="doc" name=""ent4""/> |
| <appendChild obj="gender" newChild="entRef" var="appendedChild"/> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setAttribute obj="entElement" name=""newAttr"" value=""newValue""/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/elementwrongdocumenterr.xml |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="elementwrongdocumenterr"> |
| <metadata> |
| <title>elementWrongDocumentErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method raises an |
| "WRONG_DOCUMENT_ERR DOMException if the "newAttr" |
| was created from a different document than the one that |
| created this document. |
| Retrieve the last employee and attempt to set a new |
| attribute node for its "employee" element. The new |
| attribute was created from a document other than the |
| one that created this element, therefore a |
| WRONG_DOCUMENT_ERR DOMException should be raised. |
| This test uses the "createAttribute(newAttr)" method |
| from the Document interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-887236154')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="addressElementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <var name="attrAddress" type="Attr"/> |
| <load var="doc1" href="staff" willBeModified="true"/> |
| <load var="doc2" href="staff" willBeModified="false"/> |
| <createAttribute obj="doc2" var="newAttribute" name=""newAttribute""/> |
| <getElementsByTagName interface="Document" obj="doc1" tagname=""address"" var="addressElementList"/> |
| <item interface="NodeList" obj="addressElementList" index="4" var="testAddress"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <setAttributeNode obj="testAddress" newAttr="newAttribute" var="attrAddress"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/entitygetentityname.xml.notimpl |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="entitygetentityname"> |
| <metadata> |
| <title>entityGetEntityName</title> |
| <creator>NIST</creator> |
| <description> |
| The nodeName attribute that is inherited from Node |
| contains the name of the entity. |
| Retrieve the entity named "ent1" and access its name by |
| invoking the "getNodeName()" method inherited from |
| the Node interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--Entity interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-527DCFF2"/> |
| <!--nodeName attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entityList" type="NamedNodeMap"/> |
| <var name="entityNode" type="Entity"/> |
| <var name="entityName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entityList"/> |
| <assertNotNull actual="entityList" id="entitiesNotNull"/> |
| <getNamedItem obj="entityList" var="entityNode" name=""ent1""/> |
| <nodeName obj="entityNode" var="entityName"/> |
| <assertEquals actual="entityName" expected=""ent1"" id="entityGetEntityNameAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/entitygetpublicid.xml.notimpl |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="entitygetpublicid"> |
| <metadata> |
| <title>entityGetPublicId</title> |
| <creator>NIST</creator> |
| <description> |
| The "getPublicId()" method of an Entity node contains |
| the public identifier associated with the entity, if |
| one was specified. |
| Retrieve the entity named "ent5" and access its |
| public identifier. The string "entityURI" should be |
| returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- Entity.publicId --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D7303025"/> |
| <!-- Entity.notationName --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6ABAEB38"/> |
| <!-- Entity.systemId --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D7C29F3E"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entityList" type="NamedNodeMap"/> |
| <var name="entityNode" type="Entity"/> |
| <var name="publicId" type="DOMString"/> |
| <var name="systemId" type="DOMString"/> |
| <var name="notation" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entityList"/> |
| <assertNotNull actual="entityList" id="entitiesNotNull"/> |
| <getNamedItem obj="entityList" var="entityNode" name='"ent5"'/> |
| <publicId interface="Entity" obj="entityNode" var="publicId"/> |
| <assertEquals actual="publicId" expected='"entityURI"' id="publicId" ignoreCase="false"/> |
| <systemId interface="Entity" obj="entityNode" var="systemId"/> |
| <assertURIEquals actual="systemId" file='"entityFile"' id="systemId"/> |
| <notationName interface="Entity" obj="entityNode" var="notation"/> |
| <assertEquals actual="notation" expected='"notation1"' id="notation" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/entitygetpublicidnull.xml.notimpl |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="entitygetpublicidnull"> |
| <metadata> |
| <title>entityGetPublicIdNull</title> |
| <creator>NIST</creator> |
| <description> |
| The "getPublicId()" method of an Entity node contains |
| the public identifier associated with the entity, if |
| one was not specified a null value should be returned. |
| Retrieve the entity named "ent1" and access its |
| public identifier. Since a public identifier was not |
| specified for this entity, the "getPublicId()" method |
| should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D7303025"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entityList" type="NamedNodeMap"/> |
| <var name="entityNode" type="Entity"/> |
| <var name="publicId" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entityList"/> |
| <assertNotNull actual="entityList" id="entitiesNotNull"/> |
| <getNamedItem obj="entityList" var="entityNode" name='"ent1"'/> |
| <publicId interface="Entity" obj="entityNode" var="publicId"/> |
| <assertNull actual="publicId" id="entityGetPublicIdNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/.cvsignore |
|---|
| --- test/testcases/tests/level1/core/files/CVS/Entries (nonexistent) |
| +++ test/testcases/tests/level1/core/files/CVS/Entries (revision 4364) |
| @@ -0,0 +1,16 @@ |
| +/.cvsignore/1.2/Fri Apr 3 02:48:03 2009// |
| +/hc_nodtdstaff.html/1.3/Fri Apr 3 02:48:03 2009// |
| +/hc_nodtdstaff.svg/1.2/Fri Apr 3 02:48:03 2009// |
| +/hc_nodtdstaff.xhtml/1.2/Fri Apr 3 02:48:03 2009// |
| +/hc_nodtdstaff.xml/1.3/Fri Apr 3 02:48:03 2009// |
| +/hc_staff.html/1.8/Fri Apr 3 02:48:03 2009// |
| +/hc_staff.svg/1.5/Fri Apr 3 02:48:03 2009// |
| +/hc_staff.xhtml/1.7/Fri Apr 3 02:48:03 2009// |
| +/hc_staff.xml/1.9/Fri Apr 3 02:48:03 2009// |
| +/staff.dtd/1.2/Fri Apr 3 02:48:03 2009// |
| +/staff.svg/1.3/Fri Apr 3 02:48:03 2009// |
| +/staff.xml/1.2/Fri Apr 3 02:48:03 2009// |
| +/svgtest.js/1.2/Fri Apr 3 02:48:03 2009/-kb/ |
| +/svgunit.js/1.2/Fri Apr 3 02:48:03 2009/-kb/ |
| +/xhtml1-strict.dtd/1.5/Fri Apr 3 02:48:03 2009/-kb/ |
| +D |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level1/core/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/CVS/Template |
|---|
| --- test/testcases/tests/level1/core/files/hc_nodtdstaff.html (nonexistent) |
| +++ test/testcases/tests/level1/core/files/hc_nodtdstaff.html (revision 4364) |
| @@ -0,0 +1,10 @@ |
| +<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>hc_nodtdstaff</title></head><body onload="parent.loadComplete()"> |
| + <p> |
| + <em>EMP0001</em> |
| + <strong>Margaret Martin</strong> |
| + <code>Accountant</code> |
| + <sup>56,000</sup> |
| + <var>Female</var> |
| + <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| + </p> |
| +</body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/hc_nodtdstaff.svg |
|---|
| 0,0 → 1,10 |
| <svg xmlns='http://www.w3.org/2000/svg'><rect x="0" y="0" width="100" height="100"/><head xmlns='http://www.w3.org/1999/xhtml'><title>hc_nodtdstaff</title></head><body xmlns='http://www.w3.org/1999/xhtml'> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| </body></svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/hc_nodtdstaff.xhtml |
|---|
| 0,0 → 1,10 |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>hc_nodtdstaff</title></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/hc_nodtdstaff.xml |
|---|
| 0,0 → 1,10 |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_nodtdstaff</title></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/hc_staff.html |
|---|
| 0,0 → 1,48 |
| <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" |
| "http://www.w3.org/TR/html4/strict.dtd" > |
| <!-- This is comment number 1.--> |
| <html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>hc_staff</title><script type="text/javascript" src="svgunit.js"></script><script charset="UTF-8" type="text/javascript" src="svgtest.js"></script><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p> |
| <em>EMP0002</em> |
| <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>δ</var> |
| <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/hc_staff.svg |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST acronym dir CDATA "ltr"> |
| <!ATTLIST head xmlns CDATA #IMPLIED> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| <!ELEMENT svg (rect, script, head, body)> |
| <!ATTLIST svg xmlns CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #IMPLIED |
| y CDATA #IMPLIED |
| width CDATA #IMPLIED |
| height CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <!-- This is comment number 1.--> |
| <svg xmlns='http://www.w3.org/2000/svg'><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script><head xmlns='http://www.w3.org/1999/xhtml'><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title></head><body xmlns='http://www.w3.org/1999/xhtml'> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p> |
| <em>EMP0002</em> |
| <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>δ</var> |
| <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/hc_staff.xhtml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST acronym dir CDATA "ltr"> |
| ]> |
| <!-- This is comment number 1.--> |
| <html xmlns='http://www.w3.org/1999/xhtml'><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title><script type="text/javascript" src="svgunit.js"/><script charset="UTF-8" type="text/javascript" src="svgtest.js"/><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p> |
| <em>EMP0002</em> |
| <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>δ</var> |
| <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/hc_staff.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST acronym dir CDATA "ltr"> |
| ]> |
| <!-- This is comment number 1.--> |
| <html xmlns='http://www.w3.org/1999/xhtml'><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title><script type="text/javascript" src="svgunit.js"/><script charset="UTF-8" type="text/javascript" src="svgtest.js"/><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p> |
| <em>EMP0002</em> |
| <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>δ</var> |
| <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/staff.dtd |
|---|
| 0,0 → 1,17 |
| <!ELEMENT employeeId (#PCDATA)> |
| <!ELEMENT name (#PCDATA)> |
| <!ELEMENT position (#PCDATA)> |
| <!ELEMENT salary (#PCDATA)> |
| <!ELEMENT address (#PCDATA)> |
| <!ELEMENT entElement ( #PCDATA ) > |
| <!ELEMENT gender ( #PCDATA | entElement )* > |
| <!ELEMENT employee (employeeId, name, position, salary, gender, address) > |
| <!ELEMENT staff (employee)+> |
| <!ATTLIST entElement |
| attr1 CDATA "Attr"> |
| <!ATTLIST address |
| domestic CDATA #IMPLIED |
| street CDATA "Yes"> |
| <!ATTLIST entElement |
| domestic CDATA "MALE" > |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/staff.svg |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg SYSTEM "staff.dtd" [ |
| <!ENTITY ent1 "es"> |
| <!ENTITY ent2 "1900 Dallas Road"> |
| <!ENTITY ent3 "Texas"> |
| <!ENTITY ent4 "<entElement domestic='Yes'>Element data</entElement><?PItarget PIdata?>"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ENTITY ent1 "This entity should be discarded"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST employee xmlns CDATA #IMPLIED> |
| <!ELEMENT svg (rect, script, employee+)> |
| <!ATTLIST svg |
| xmlns CDATA #FIXED "http://www.w3.org/2000/svg" |
| name CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <!-- This is comment number 1.--> |
| <svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgunit;&svgtest;</script> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds<![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Yes">&ent2; Dallas, &ent3; |
| 98554</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>&ent4;</gender> |
| <address domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0004</employeeId> |
| <name>Jeny Oconnor</name> |
| <position>Personnel Director</position> |
| <salary>95,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Y&ent1;">27 South Road. Dallas, Texas 98556</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/staff.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE staff SYSTEM "staff.dtd" [ |
| <!ENTITY ent1 "es"> |
| <!ENTITY ent2 "1900 Dallas Road"> |
| <!ENTITY ent3 "Texas"> |
| <!ENTITY ent4 "<entElement domestic='Yes'>Element data</entElement><?PItarget PIdata?>"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ENTITY ent1 "This entity should be discarded"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| ]> |
| <!-- This is comment number 1.--> |
| <staff> |
| <employee> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds<![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Yes">&ent2; Dallas, &ent3; |
| 98554</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>&ent4;</gender> |
| <address domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0004</employeeId> |
| <name>Jeny Oconnor</name> |
| <position>Personnel Director</position> |
| <salary>95,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Y&ent1;">27 South Road. Dallas, Texas 98556</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </staff> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/files/xhtml1-strict.dtd |
|---|
| 0,0 → 1,65 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This is a radically simplified DTD for use in the DOM Test Suites |
| due to a XML non-conformance of one implementation in processing |
| parameter entities. When that non-conformance is resolved, |
| this DTD can be replaced by the normal DTD for XHTML. |
| --> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (meta,title,script*)> |
| <!ELEMENT meta EMPTY> |
| <!ATTLIST meta |
| http-equiv CDATA #IMPLIED |
| content CDATA #IMPLIED> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT body (p*)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|em|strong|code|sup|var|acronym|abbr)*> |
| <!ATTLIST p |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT em (#PCDATA)> |
| <!ELEMENT span (#PCDATA)> |
| <!ELEMENT strong (#PCDATA)> |
| <!ELEMENT code (#PCDATA)> |
| <!ELEMENT sup (#PCDATA)> |
| <!ELEMENT var (#PCDATA|span)*> |
| <!ELEMENT acronym (#PCDATA)> |
| <!ATTLIST acronym |
| title CDATA #IMPLIED |
| class CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT abbr (#PCDATA)> |
| <!ATTLIST abbr |
| title CDATA #IMPLIED |
| class CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| type CDATA #IMPLIED |
| src CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrappendchild1.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrappendchild1"> |
| <metadata> |
| <title>hc_attrappendchild1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Appends a text node to an attribute and checks if the value of |
| the attribute is changed. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.appendChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="textNode" obj="doc" data='"terday"'/> |
| <appendChild var="retval" obj="titleAttr" newChild="textNode"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that retval is the appended node --> |
| <nodeValue obj="retval" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="retvalValue" ignoreCase="false"/> |
| <!-- check that lastChild is the appended node --> |
| <lastChild var="lastChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="lastChild" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="lastChildValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrappendchild2.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrappendchild2"> |
| <metadata> |
| <title>hc_attrappendchild2</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempts to append an element to the child nodes of an attribute. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.appendChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="newChild" type="Node"/> |
| <var name="retval" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createElement var="newChild" obj="doc" tagName='"terday"'/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <appendChild var="retval" obj="titleAttr" newChild="newChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrappendchild3.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrappendchild3"> |
| <metadata> |
| <title>hc_attrappendchild3</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Appends a document fragment to an attribute and checks if the value of |
| the attribute is changed. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.appendChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="terNode" type="Text"/> |
| <var name="dayNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="terNode" obj="doc" data='"ter"'/> |
| <createTextNode var="dayNode" obj="doc" data='"day"'/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <appendChild var="retval" obj="docFrag" newChild="terNode"/> |
| <appendChild var="retval" obj="docFrag" newChild="dayNode"/> |
| <appendChild var="retval" obj="titleAttr" newChild="docFrag"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that retval is the document fragment --> |
| <nodeValue obj="retval" var="value"/> |
| <assertNull actual="value" id="retvalValue"/> |
| <!-- check that lastChild is the final node in the doc fragment node --> |
| <lastChild var="lastChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="lastChild" var="value"/> |
| <assertEquals actual="value" expected='"day"' id="lastChildValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrappendchild4.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrappendchild4"> |
| <metadata> |
| <title>hc_attrappendchild4</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to append a CDATASection to an attribute which should result |
| in a HIERARCHY_REQUEST_ERR. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.appendChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Node"/> |
| <var name="retval" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <if><contentType type="text/html"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createCDATASection var="textNode" obj="doc" data='"terday"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <else> |
| <createCDATASection var="textNode" obj="doc" data='"terday"'/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <appendChild var="retval" obj="titleAttr" newChild="textNode"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrappendchild5.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrappendchild5"> |
| <metadata> |
| <title>hc_attrappendchild5</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to append a node from another document to an attribute which should result |
| in a WRONG_DOCUMENT_ERR. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.appendChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Node"/> |
| <var name="retval" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <var name="otherDoc" type="Document"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <load var="otherDoc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="textNode" obj="otherDoc" data='"terday"'/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <appendChild var="retval" obj="titleAttr" newChild="textNode"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrappendchild6.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrappendchild6"> |
| <metadata> |
| <title>hc_attrappendchild6</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Creates an new attribute node and appends a text node. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.appendChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttribute var="titleAttr" obj="doc" name='"title"'/> |
| <createTextNode var="textNode" obj="doc" data='"Yesterday"'/> |
| <appendChild var="retval" obj="titleAttr" newChild="textNode"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that retval is the appended node --> |
| <nodeValue obj="retval" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="retvalValue" ignoreCase="false"/> |
| <!-- check that lastChild is the appended node --> |
| <lastChild var="lastChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="lastChild" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="lastChildValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrchildnodes1.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrchildnodes1"> |
| <metadata> |
| <title>hc_attrchildnodes1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.childNodes for an attribute node contains |
| the expected text node. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.childNodes --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="childNodes" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <childNodes var="childNodes" obj="titleAttr"/> |
| <assertSize size="1" collection="childNodes" id="childNodesSize"/> |
| <item var="textNode" obj="childNodes" index="0" interface="NodeList"/> |
| <nodeValue var="value" obj="textNode"/> |
| <assertEquals actual="value" expected='"Yes"' id="child1IsYes" ignoreCase="false"/> |
| <item var="textNode" obj="childNodes" index="1" interface="NodeList"/> |
| <assertNull actual="textNode" id="secondItemIsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrchildnodes2.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrchildnodes2"> |
| <metadata> |
| <title>hc_attrchildnodes2</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks Node.childNodes for an attribute with multiple child nodes. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.childNodes --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="childNodes" type="NodeList"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <childNodes var="childNodes" obj="titleAttr"/> |
| <createTextNode var="textNode" obj="doc" data='"terday"'/> |
| <appendChild var="retval" obj="titleAttr" newChild="textNode"/> |
| <assertSize size="2" collection="childNodes" id="childNodesSize"/> |
| <item var="textNode" obj="childNodes" index="0" interface="NodeList"/> |
| <nodeValue var="value" obj="textNode"/> |
| <assertEquals actual="value" expected='"Yes"' id="child1IsYes" ignoreCase="false"/> |
| <item var="textNode" obj="childNodes" index="1" interface="NodeList"/> |
| <nodeValue var="value" obj="textNode"/> |
| <assertEquals actual="value" expected='"terday"' id="child2IsTerday" ignoreCase="false"/> |
| <item var="textNode" obj="childNodes" index="2" interface="NodeList"/> |
| <assertNull actual="textNode" id="thirdItemIsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrclonenode1.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrclonenode1"> |
| <metadata> |
| <title>hc_attrclonenode1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Appends a text node to an attribute and clones the node. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.cloneNode --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <var name="clonedTitle" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="textNode" obj="doc" data='"terday"'/> |
| <appendChild var="retval" obj="titleAttr" newChild="textNode"/> |
| <cloneNode var="clonedTitle" obj="titleAttr" deep="false"/> |
| <!-- change the original text node, should not affect the clone --> |
| <nodeValue obj="textNode" value='"text_node_not_cloned"'/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="clonedTitle" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="clonedTitle" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that lastChild is the the expected value --> |
| <lastChild var="lastChild" obj="clonedTitle" interface="Node"/> |
| <nodeValue obj="lastChild" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="lastChildValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrcreatedocumentfragment.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrcreatedocumentfragment"> |
| <metadata> |
| <title>hc_attrcreatedocumentfragment</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a new DocumentFragment and add a newly created Element node(with one attribute). |
| Once the element is added, its attribute should be available as an attribute associated |
| with an Element within a DocumentFragment. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!-- createDocumentFragment --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-35CB04B5"/> |
| <!-- setAttribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| <!-- DocumentFragment --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A3"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Jun/0011.html"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=184"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="newOne" type="Element"/> |
| <var name="domesticNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="attribute" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="langAttrCount" type="int" value="0"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="docFragment"/> |
| <createElement obj="doc" var="newOne" tagName='"html"'/> |
| <setAttribute obj="newOne" name='"lang"' value='"EN"'/> |
| <appendChild var="appendedChild" obj="docFragment" newChild="newOne"/> |
| <firstChild interface="Node" obj="docFragment" var="domesticNode"/> |
| <attributes obj="domesticNode" var="attributes"/> |
| <for-each collection="attributes" member="attribute"> |
| <nodeName var="attrName" obj="attribute"/> |
| <if><equals expected='"lang"' actual="attrName" ignoreCase="auto" context="attribute"/> |
| <increment var="langAttrCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals expected="1" actual="langAttrCount" id="hasLangAttr" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrcreatetextnode.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrcreatetextnode"> |
| <metadata> |
| <title>hc_attrCreateTextNode</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setValue()" method for an attribute creates a |
| Text node with the unparsed content of the string. |
| Retrieve the attribute named "class" from the last |
| child of of the fourth employee and assign the "Y&ent1;" |
| string to its value attribute. This value is not yet |
| parsed and therefore should still be the same upon |
| retrieval. This test uses the "getNamedItem(name)" method |
| from the NamedNodeMap interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!-- Attr.value --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-221662474"/> |
| <!-- bug report on initial version --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Apr/0057.html"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name='"class"'/> |
| <value interface="Attr" obj="streetAttr" value='"Y&ent1;"'/> |
| <value interface="Attr" obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected='"Y&ent1;"' id="value" ignoreCase="false"/> |
| <nodeValue obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected='"Y&ent1;"' id="nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrcreatetextnode2.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrcreatetextnode2"> |
| <metadata> |
| <title>hc_attrCreateTextNode2</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setNodeValue()" method for an attribute creates a |
| Text node with the unparsed content of the string. |
| Retrieve the attribute named "class" from the last |
| child of of the fourth employee and assign the "Y&ent1;" |
| string to its value attribute. This value is not yet |
| parsed and therefore should still be the same upon |
| retrieval. This test uses the "getNamedItem(name)" method |
| from the NamedNodeMap interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!-- Node.nodeValue --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <!-- bug report on initial version --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Apr/0057.html"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name='"class"'/> |
| <nodeValue obj="streetAttr" value='"Y&ent1;"'/> |
| <value interface="Attr" obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected='"Y&ent1;"' id="value" ignoreCase="false"/> |
| <nodeValue obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected='"Y&ent1;"' id="nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attreffectivevalue.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attreffectivevalue"> |
| <metadata> |
| <title>hc_attrEffectiveValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If an Attr is explicitly assigned any value, then that value is the attributes effective value. |
| Retrieve the attribute named "domestic" from the last child of of the first employee |
| and examine its nodeValue attribute. This test uses the "getNamedItem(name)" method |
| from the NamedNodeMap interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!-- Element.attributes --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- NamedNodeMap.getNamedItem --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1074577549"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name='"title"'/> |
| <nodeValue obj="domesticAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yes"' id="attrEffectiveValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrfirstchild.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrfirstchild"> |
| <metadata> |
| <title>hc_attrfirstchild</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.firstChild for an attribute node contains |
| the expected text node. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.firstChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-169727388"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="otherChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <firstChild var="textNode" obj="titleAttr" interface="Node"/> |
| <assertNotNull actual="textNode" id="textNodeNotNull"/> |
| <nodeValue var="value" obj="textNode"/> |
| <assertEquals actual="value" expected='"Yes"' id="child1IsYes" ignoreCase="false"/> |
| <nextSibling var="otherChild" obj="textNode" interface="Node"/> |
| <assertNull actual="otherChild" id="nextSiblingIsNull"/> |
| <previousSibling var="otherChild" obj="textNode" interface="Node"/> |
| <assertNull actual="otherChild" id="previousSiblingIsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrgetvalue1.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrgetvalue1"> |
| <metadata> |
| <title>hc_attrgetvalue1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks the value of an attribute that contains entity references. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr.value --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-221662474"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"class"'/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yα"' id="attrValue1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrgetvalue2.xml.kfail |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrgetvalue2"> |
| <metadata> |
| <title>hc_attrgetvalue2</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks the value of an attribute that contains entity references. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr.value --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-221662474"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="alphaRef" type="EntityReference"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"class"'/> |
| <if><contentType type="text/html"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createEntityReference var="alphaRef" obj="doc" name='"alpha"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <else> |
| <!-- create an alpha entity reference and place it first --> |
| <createEntityReference var="alphaRef" obj="doc" name='"alpha"'/> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <insertBefore var="retval" obj="titleAttr" newChild="alphaRef" refChild="firstChild"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"αYα"' id="attrValue1" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrhaschildnodes.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrhaschildnodes"> |
| <metadata> |
| <title>hc_attrhaschildnodes</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.hasChildNodes() is true for an attribute with content. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.hasChildNodes --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-810594187"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="hasChildNodes" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <hasChildNodes var="hasChildNodes" obj="titleAttr"/> |
| <assertTrue actual="hasChildNodes" id="hasChildrenIsTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrinsertbefore1.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrinsertbefore1"> |
| <metadata> |
| <title>hc_attrinsertbefore1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Appends a text node to an attribute and checks if the value of |
| the attribute is changed. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.insertBefore --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <var name="refChild" type="Node" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="textNode" obj="doc" data='"terday"'/> |
| <insertBefore var="retval" obj="titleAttr" newChild="textNode" refChild="refChild"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that retval is the appended node --> |
| <nodeValue obj="retval" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="retvalValue" ignoreCase="false"/> |
| <!-- check that firstChild is the existing node --> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="firstChild" var="value"/> |
| <assertEquals actual="value" expected='"Yes"' id="firstChildValue" ignoreCase="false"/> |
| <!-- check that lastChild is the appended node --> |
| <lastChild var="lastChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="lastChild" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="lastChildValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrinsertbefore2.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrinsertbefore2"> |
| <metadata> |
| <title>hc_attrinsertbefore2</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Prepends a text node to an attribute and checks if the value of |
| the attribute is changed. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.insertBefore --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="refChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="textNode" obj="doc" data='"terday"'/> |
| <firstChild var="refChild" obj="titleAttr" interface="Node"/> |
| <insertBefore var="retval" obj="titleAttr" newChild="textNode" refChild="refChild"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"terdayYes"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"terdayYes"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that retval is the appended node --> |
| <nodeValue obj="retval" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="retvalValue" ignoreCase="false"/> |
| <!-- check that firstChild is the prepended node --> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="firstChild" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="firstChildValue" ignoreCase="false"/> |
| <!-- check that lastChild is the original node --> |
| <lastChild var="lastChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="lastChild" var="value"/> |
| <assertEquals actual="value" expected='"Yes"' id="lastChildValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrinsertbefore3.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrinsertbefore3"> |
| <metadata> |
| <title>hc_attrinsertbefore3</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Appends a document fragment to an attribute and checks if the value of |
| the attribute is changed. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.insertBefore --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="terNode" type="Text"/> |
| <var name="dayNode" type="Text"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <var name="refChild" type="Node" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="terNode" obj="doc" data='"ter"'/> |
| <createTextNode var="dayNode" obj="doc" data='"day"'/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <appendChild var="retval" obj="docFrag" newChild="terNode"/> |
| <appendChild var="retval" obj="docFrag" newChild="dayNode"/> |
| <insertBefore var="retval" obj="titleAttr" newChild="docFrag" refChild="refChild"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that retval is the appended node --> |
| <nodeValue obj="retval" var="value"/> |
| <assertNull actual="value" id="retvalValue"/> |
| <!-- check that firstChild is the existing node --> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="firstChild" var="value"/> |
| <assertEquals actual="value" expected='"Yes"' id="firstChildValue" ignoreCase="false"/> |
| <!-- check that lastChild is the last child of the doc fragment --> |
| <lastChild var="lastChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="lastChild" var="value"/> |
| <assertEquals actual="value" expected='"day"' id="lastChildValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrinsertbefore4.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrinsertbefore4"> |
| <metadata> |
| <title>hc_attrinsertbefore4</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Prepends a document fragment to an attribute and checks if the value of |
| the attribute is changed. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.insertBefore --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="terNode" type="Text"/> |
| <var name="dayNode" type="Text"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <var name="refChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="terNode" obj="doc" data='"ter"'/> |
| <createTextNode var="dayNode" obj="doc" data='"day"'/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <appendChild var="retval" obj="docFrag" newChild="terNode"/> |
| <appendChild var="retval" obj="docFrag" newChild="dayNode"/> |
| <firstChild var="refChild" obj="titleAttr" interface="Node"/> |
| <insertBefore var="retval" obj="titleAttr" newChild="docFrag" refChild="refChild"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"terdayYes"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"terdayYes"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that retval is the appended node --> |
| <nodeValue obj="retval" var="value"/> |
| <assertNull actual="value" id="retvalValue"/> |
| <!-- check that firstChild is the first node in the document fragment --> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="firstChild" var="value"/> |
| <assertEquals actual="value" expected='"ter"' id="firstChildValue" ignoreCase="false"/> |
| <!-- check that last child is the original node --> |
| <lastChild var="lastChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="lastChild" var="value"/> |
| <assertEquals actual="value" expected='"Yes"' id="lastChildValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrinsertbefore5.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrinsertbefore5"> |
| <metadata> |
| <title>hc_attrinsertbefore5</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to append a CDATASection to an attribute which should result |
| in a HIERARCHY_REQUEST_ERR. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.insertBefore --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Node"/> |
| <var name="retval" type="Node"/> |
| <var name="refChild" type="Node" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <if><contentType type="text/html"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createCDATASection var="textNode" obj="doc" data='"terday"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <else> |
| <createCDATASection var="textNode" obj="doc" data='"terday"'/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore var="retval" obj="titleAttr" newChild="textNode" refChild="refChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrinsertbefore6.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrinsertbefore6"> |
| <metadata> |
| <title>hc_attrinsertbefore6</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to append a text node from another document to an attribute which should result |
| in a WRONG_DOCUMENT_ERR. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.insertBefore --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Node"/> |
| <var name="retval" type="Node"/> |
| <var name="refChild" type="Node" isNull="true"/> |
| <var name="otherDoc" type="Document"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <load var="otherDoc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="textNode" obj="otherDoc" data='"terday"'/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <insertBefore var="retval" obj="titleAttr" newChild="textNode" refChild="refChild"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrinsertbefore7.xml |
|---|
| 0,0 → 1,69 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrinsertbefore7"> |
| <metadata> |
| <title>hc_attrinsertbefore7</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Appends a document fragment containing a CDATASection to an attribute. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.insertBefore --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="terNode" type="Text"/> |
| <var name="dayNode" type="Node"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <var name="refChild" type="Node" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="terNode" obj="doc" data='"ter"'/> |
| <if><contentType type="text/html"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createCDATASection var="dayNode" obj="doc" data='"day"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <else> |
| <createCDATASection var="dayNode" obj="doc" data='"day"'/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <appendChild var="retval" obj="docFrag" newChild="terNode"/> |
| <appendChild var="retval" obj="docFrag" newChild="dayNode"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore var="retval" obj="titleAttr" newChild="docFrag" refChild="refChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrlastchild.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrlastchild"> |
| <metadata> |
| <title>hc_attrlastchild</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.lastChild for an attribute node contains |
| the expected text node. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.lastChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-61AD09FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="otherChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <firstChild var="textNode" obj="titleAttr" interface="Node"/> |
| <assertNotNull actual="textNode" id="textNodeNotNull"/> |
| <nodeValue var="value" obj="textNode"/> |
| <assertEquals actual="value" expected='"Yes"' id="child1IsYes" ignoreCase="false"/> |
| <nextSibling var="otherChild" obj="textNode" interface="Node"/> |
| <assertNull actual="otherChild" id="nextSiblingIsNull"/> |
| <previousSibling var="otherChild" obj="textNode" interface="Node"/> |
| <assertNull actual="otherChild" id="previousSiblingIsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrname.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrname"> |
| <metadata> |
| <title>hc_attrName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the attribute named class from the last |
| child of of the second "p" element and examine its |
| NodeName. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!-- Node.nodeName --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <!-- Attr.name --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1112119403"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Jun/0011.html"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="strong1" type="DOMString"/> |
| <var name="strong2" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="1"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name='"class"'/> |
| <nodeName obj="streetAttr" var="strong1"/> |
| <name obj="streetAttr" var="strong2" interface="Attr"/> |
| <assertEquals actual="strong1" expected='"class"' id="nodeName" ignoreCase="auto" context="attribute"/> |
| <assertEquals actual="strong2" expected='"class"' id="name" ignoreCase="auto" context="attribute"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrnextsiblingnull.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrnextsiblingnull"> |
| <metadata> |
| <title>hc_attrNextSiblingNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getNextSibling()" method for an Attr node should return null. |
| Retrieve the attribute named "domestic" from the last child of of the |
| first employee and examine its NextSibling node. This test uses the |
| "getNamedItem(name)" method from the NamedNodeMap interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--nextSibling attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6AC54C2F"/> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="s" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name='"title"'/> |
| <nextSibling interface="Node" obj="domesticAttr" var="s"/> |
| <assertNull actual="s" id="attrNextSiblingNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrnormalize.xml.notimpl |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrnormalize"> |
| <metadata> |
| <title>hc_attrnormalize</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Appends a text node to an attribute, normalizes the attribute |
| and checks for a single child node. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.normalize --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-162CF083"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="secondChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="textNode" obj="doc" data='"terday"'/> |
| <appendChild var="retval" obj="titleAttr" newChild="textNode"/> |
| <createTextNode var="textNode" obj="doc" data='""'/> |
| <appendChild var="retval" obj="titleAttr" newChild="textNode"/> |
| <!-- in level 1, normalize is on element --> |
| <normalize obj="testNode"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that first child has all the content --> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="firstChild" var="value"/> |
| <assertEquals actual="value" expected='"Yesterday"' id="firstChildValue" ignoreCase="false"/> |
| <nextSibling var="secondChild" obj="firstChild" interface="Node"/> |
| <assertNull actual="secondChild" id="secondChildIsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrparentnodenull.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrparentnodenull"> |
| <metadata> |
| <title>hc_attrParentNodeNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getParentNode()" method for an Attr node should return null. Retrieve |
| the attribute named "domestic" from the last child of the first employee |
| and examine its parentNode attribute. This test also uses the "getNamedItem(name)" |
| method from the NamedNodeMap interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--parentNode attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1060184317"/> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="s" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name='"title"'/> |
| <parentNode interface="Node" obj="domesticAttr" var="s"/> |
| <assertNull actual="s" id="attrParentNodeNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrprevioussiblingnull.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrprevioussiblingnull"> |
| <metadata> |
| <title>hc_attrPreviousSiblingNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getPreviousSibling()" method for an Attr node should return null. |
| Retrieve the attribute named "domestic" from the last child of of the |
| first employee and examine its PreviousSibling node. This test uses the |
| "getNamedItem(name)" method from the NamedNodeMap interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--previousSibling attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-640FB3C8"/> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="s" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name='"title"'/> |
| <previousSibling interface="Node" obj="domesticAttr" var="s"/> |
| <assertNull actual="s" id="attrPreviousSiblingNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrremovechild1.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrremovechild1"> |
| <metadata> |
| <title>hc_attrremovechild1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Removes the child node of an attribute and checks that the value is empty. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.removeChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <firstChild var="textNode" obj="titleAttr" interface="Node"/> |
| <assertNotNull actual="textNode" id="attrChildNotNull"/> |
| <removeChild var="retval" obj="titleAttr" oldChild="textNode"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='""' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='""' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that retval is the removed node --> |
| <nodeValue obj="retval" var="value"/> |
| <assertEquals actual="value" expected='"Yes"' id="retvalValue" ignoreCase="false"/> |
| <!-- check that firstChild is null --> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <assertNull actual="firstChild" id="firstChildNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrremovechild2.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrremovechild2"> |
| <metadata> |
| <title>hc_attrremovechild2</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempts to remove a freshly created text node which should result in a NOT_FOUND_ERR exception. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.removeChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="textNode" obj="doc" data='"Yesterday"'/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild var="retval" obj="titleAttr" oldChild="textNode"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrreplacechild1.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrreplacechild1"> |
| <metadata> |
| <title>hc_attrreplacechild1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Replaces a text node of an attribute and checks if the value of |
| the attribute is changed. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.replaceChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="textNode" obj="doc" data='"terday"'/> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <assertNotNull actual="firstChild" id="attrChildNotNull"/> |
| <replaceChild var="retval" obj="titleAttr" newChild="textNode" oldChild="firstChild"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that retval is the removed node --> |
| <nodeValue obj="retval" var="value"/> |
| <assertEquals actual="value" expected='"Yes"' id="retvalValue" ignoreCase="false"/> |
| <!-- check that firstChild is the appended node --> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="firstChild" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="firstChildValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrreplacechild2.xml |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrreplacechild2"> |
| <metadata> |
| <title>hc_attrreplacechild2</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Replaces a text node of an attribute with a document fragment and checks if the value of |
| the attribute is changed. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!-- Node.replaceChild --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="terNode" type="Text"/> |
| <var name="dayNode" type="Text"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="terNode" obj="doc" data='"ter"'/> |
| <createTextNode var="dayNode" obj="doc" data='"day"'/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <appendChild var="retval" obj="docFrag" newChild="terNode"/> |
| <appendChild var="retval" obj="docFrag" newChild="dayNode"/> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <assertNotNull actual="firstChild" id="attrChildNotNull"/> |
| <replaceChild var="retval" obj="titleAttr" newChild="docFrag" oldChild="firstChild"/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"terday"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that retval is the removed node --> |
| <nodeValue obj="retval" var="value"/> |
| <assertEquals actual="value" expected='"Yes"' id="retvalValue" ignoreCase="false"/> |
| <!-- check that firstChild is the first node of the doc fragment --> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="firstChild" var="value"/> |
| <assertEquals actual="value" expected='"ter"' id="firstChildValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrsetvalue1.xml |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrsetvalue1"> |
| <metadata> |
| <title>hc_attrsetvalue1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Sets Attr.value on an attribute that only has a simple value. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr.value --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-221662474"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="otherChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <assertNotNull actual="firstChild" id="attrChildNotNull"/> |
| <!-- set value which should totally replace child node list --> |
| <value obj="titleAttr" value='"Tomorrow"' interface="Attr"/> |
| <!-- setting the previous first child should have not |
| affect on current value --> |
| <nodeValue obj="firstChild" value='"impl reused node"'/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Tomorrow"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Tomorrow"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that firstChild is an implicitly created node --> |
| <lastChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="firstChild" var="value"/> |
| <assertEquals actual="value" expected='"Tomorrow"' id="firstChildValue" ignoreCase="false"/> |
| <nextSibling var="otherChild" obj="firstChild" interface="Node"/> |
| <assertNull actual="otherChild" id="nextSiblingIsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrsetvalue2.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrsetvalue2"> |
| <metadata> |
| <title>hc_attrsetvalue2</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Sets Attr.value on an attribute that should contain multiple child nodes. |
| </description> |
| <date qualifier="created">2004-01-01</date> |
| <!-- Attr.value --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-221662474"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="otherChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="acronymList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="acronymList" var="testNode" index="3"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="titleAttr" name='"title"'/> |
| <createTextNode var="textNode" obj="doc" data='"terday"'/> |
| <appendChild var="retval" obj="titleAttr" newChild="textNode"/> |
| <firstChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <assertNotNull actual="firstChild" id="attrChildNotNull"/> |
| <!-- set value which should totally replace child node list --> |
| <value obj="titleAttr" value='"Tomorrow"' interface="Attr"/> |
| <!-- setting the previous first child should have not |
| affect on current value --> |
| <nodeValue obj="firstChild" value='"impl reused node"'/> |
| <!-- check that Attr.value gives expected result --> |
| <value interface="Attr" obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Tomorrow"' id="attrValue" ignoreCase="false"/> |
| <!-- check that Node.value gives expected result --> |
| <nodeValue obj="titleAttr" var="value"/> |
| <assertEquals actual="value" expected='"Tomorrow"' id="attrNodeValue" ignoreCase="false"/> |
| <!-- check that firstChild is an implicitly created node --> |
| <lastChild var="firstChild" obj="titleAttr" interface="Node"/> |
| <nodeValue obj="firstChild" var="value"/> |
| <assertEquals actual="value" expected='"Tomorrow"' id="firstChildValue" ignoreCase="false"/> |
| <nextSibling var="otherChild" obj="firstChild" interface="Node"/> |
| <assertNull actual="otherChild" id="nextSiblingIsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrspecifiedvalue.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrspecifiedvalue"> |
| <metadata> |
| <title>hc_attrSpecifiedValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getSpecified()" method for an Attr node should |
| be set to true if the attribute was explicitly given |
| a value. |
| Retrieve the attribute named "domestic" from the last |
| child of of the first employee and examine the value |
| returned by the "getSpecified()" method. This test uses |
| the "getNamedItem(name)" method from the NamedNodeMap |
| interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-862529273"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name='"title"'/> |
| <specified obj="domesticAttr" var="state"/> |
| <assertTrue actual="state" id="acronymTitleSpecified"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_attrspecifiedvaluechanged.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_attrspecifiedvaluechanged"> |
| <metadata> |
| <title>hc_attrSpecifiedValueChanged</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getSpecified()" method for an Attr node should return true if the |
| value of the attribute is changed. |
| Retrieve the attribute named "class" from the last |
| child of of the THIRD employee and change its |
| value to "Yes"(which is the default DTD value). This |
| should cause the "getSpecified()" method to be true. |
| This test uses the "setAttribute(name,value)" method |
| from the Element interface and the "getNamedItem(name)" |
| method from the NamedNodeMap interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-862529273"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="2"/> |
| <setAttribute obj="testNode" name='"class"' value='"Yα"'/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name='"class"'/> |
| <specified obj="streetAttr" var="state"/> |
| <assertTrue actual="state" id="acronymClassSpecified"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataappenddata.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataappenddata"> |
| <metadata> |
| <title>hc_characterdataAppendData</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "appendData(arg)" method appends a string to the end |
| of the character data of the node. |
| Retrieve the character data from the second child |
| of the first employee. The appendData(arg) method is |
| called with arg=", Esquire". The method should append |
| the specified data to the already existing character |
| data. The new value return by the "getLength()" method |
| should be 24. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-32791A2F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="childLength" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <appendData obj="child" arg='", Esquire"'/> |
| <data obj="child" var="childValue" interface="CharacterData"/> |
| <length obj="childValue" var="childLength" interface="DOMString"/> |
| <assertEquals actual="childLength" expected="24" ignoreCase="false" id="characterdataAppendDataAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataappenddatagetdata.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataappenddatagetdata"> |
| <metadata> |
| <title>hc_characterdataAppendDataGetData</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| On successful invocation of the "appendData(arg)" |
| method the "getData()" method provides access to the |
| concatentation of data and the specified string. |
| Retrieve the character data from the second child |
| of the first employee. The appendData(arg) method is |
| called with arg=", Esquire". The method should append |
| the specified data to the already existing character |
| data. The new value return by the "getData()" method |
| should be "Margaret Martin, Esquire". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-32791A2F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <appendData obj="child" arg='", Esquire"'/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"Margaret Martin, Esquire"' id="characterdataAppendDataGetDataAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatadeletedatabegining.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatadeletedatabegining"> |
| <metadata> |
| <title>hc_characterdataDeleteDataBeginning</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "deleteData(offset,count)" method removes a range of |
| characters from the node. Delete data at the beginning |
| of the character data. |
| Retrieve the character data from the last child of the |
| first employee. The "deleteData(offset,count)" |
| method is then called with offset=0 and count=16. |
| The method should delete the characters from position |
| 0 thru position 16. The new value of the character data |
| should be "Dallas, Texas 98551". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <deleteData obj="child" offset="0" count="16"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"Dallas, Texas 98551"' id="data" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatadeletedataend.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatadeletedataend"> |
| <metadata> |
| <title>hc_characterdataDeleteDataEnd</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "deleteData(offset,count)" method removes a range of |
| characters from the node. Delete data at the end |
| of the character data. |
| Retrieve the character data from the last child of the |
| first employee. The "deleteData(offset,count)" |
| method is then called with offset=30 and count=5. |
| The method should delete the characters from position |
| 30 thru position 35. The new value of the character data |
| should be "1230 North Ave. Dallas, Texas". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <deleteData obj="child" offset="30" count="5"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"1230 North Ave. Dallas, Texas "' id="characterdataDeleteDataEndAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatadeletedataexceedslength.xml.kfail |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatadeletedataexceedslength"> |
| <metadata> |
| <title>hc_characterdataDeleteDataExceedsLength</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the sum of the offset and count used in the |
| "deleteData(offset,count) method is greater than the |
| length of the character data then all the characters |
| from the offset to the end of the data are deleted. |
| Retrieve the character data from the last child of the |
| first employee. The "deleteData(offset,count)" |
| method is then called with offset=4 and count=50. |
| The method should delete the characters from position 4 |
| to the end of the data since the offset+count(50+4) |
| is greater than the length of the character data(35). |
| The new value of the character data should be "1230". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <deleteData obj="child" offset="4" count="50"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"1230"' id="characterdataDeleteDataExceedsLengthAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatadeletedatagetlengthanddata.xml.kfail |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatadeletedatagetlengthanddata"> |
| <metadata> |
| <title>hc_characterdataDeleteDataGetLengthAndData</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| On successful invocation of the "deleteData(offset,count)" |
| method, the "getData()" and "getLength()" methods reflect |
| the changes. |
| Retrieve the character data from the last child of the |
| first employee. The "deleteData(offset,count)" |
| method is then called with offset=30 and count=5. |
| The method should delete the characters from position |
| 30 thru position 35. The new value of the character data |
| should be "1230 North Ave. Dallas, Texas" which is |
| returned by the "getData()" method and "getLength()" |
| method should return 30". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7D61178C"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <var name="childLength" type="int"/> |
| <var name="result" type="List"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <deleteData obj="child" offset="30" count="5"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"1230 North Ave. Dallas, Texas "' ignoreCase="false" id="data"/> |
| <length interface="CharacterData" obj="child" var="childLength"/> |
| <assertEquals actual="childLength" expected="30" ignoreCase="false" id="length"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatadeletedatamiddle.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatadeletedatamiddle"> |
| <metadata> |
| <title>hc_characterdataDeleteDataMiddle</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "deleteData(offset,count)" method removes a range of |
| characters from the node. Delete data in the middle |
| of the character data. |
| Retrieve the character data from the last child of the |
| first employee. The "deleteData(offset,count)" |
| method is then called with offset=16 and count=8. |
| The method should delete the characters from position |
| 16 thru position 24. The new value of the character data |
| should be "1230 North Ave. Texas 98551". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <deleteData obj="child" offset="16" count="8"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"1230 North Ave. Texas 98551"' id="characterdataDeleteDataMiddleAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatagetdata.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatagetdata"> |
| <metadata> |
| <title>hc_characterdataGetData</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getData()" method retrieves the character data |
| currently stored in the node. |
| Retrieve the character data from the second child |
| of the first employee and invoke the "getData()" |
| method. The method returns the character data |
| string. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"Margaret Martin"' id="characterdataGetDataAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatagetlength.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatagetlength"> |
| <metadata> |
| <title>hc_characterdataGetLength</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getLength()" method returns the number of characters |
| stored in this nodes data. |
| Retrieve the character data from the second |
| child of the first employee and examine the |
| value returned by the getLength() method. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7D61178C"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="childLength" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <data var="childValue" obj="child" interface="CharacterData"/> |
| <length var="childLength" obj="childValue" interface="DOMString"/> |
| <assertEquals actual="childLength" expected="15" ignoreCase="false" id="characterdataGetLengthAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrdeletedatacountnegative.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrdeletedatacountnegative"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrDeleteDataCountNegative</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "deleteData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified count |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "deleteData(offset,count)" |
| method with offset=10 and count=-3. It should raise the |
| desired exception since the count is negative. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6531BCCF')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childSubstring" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <substringData var="childSubstring" obj="child" offset="10" count="-3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrdeletedataoffsetgreater.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrdeletedataoffsetgreater"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrDeleteDataOffsetGreater</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "deleteData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is greater that the number of characters in the string. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "deleteData(offset,count)" |
| method with offset=40 and count=3. It should raise the |
| desired exception since the offset is greater than the |
| number of characters in the string. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-7C603781')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throw_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <deleteData obj="child" offset="40" count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrdeletedataoffsetnegative.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrdeletedataoffsetnegative"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrDeleteDataOffsetNegative</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "deleteData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "deleteData(offset,count)" |
| method with offset=-5 and count=3. It should raise the |
| desired exception since the offset is negative. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-7C603781')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <deleteData obj="child" offset="-5" count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrinsertdataoffsetgreater.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrinsertdataoffsetgreater"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrInsertDataOffsetGreater</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertData(offset,arg)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is greater than the number of characters in the string. |
| Retrieve the character data of the last child of the |
| first employee and invoke its insertData"(offset,arg)" |
| method with offset=40 and arg="ABC". It should raise |
| the desired exception since the offset is greater than |
| the number of characters in the string. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-7C603781')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throw_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <deleteData obj="child" offset="40" count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrinsertdataoffsetnegative.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrinsertdataoffsetnegative"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrInsertDataOffsetNegative</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertData(offset,arg)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its insertData"(offset,arg)" |
| method with offset=-5 and arg="ABC". It should raise |
| the desired exception since the offset is negative. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-E5CBA7FB')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <replaceData obj="child" offset="-5" arg='"ABC"' count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrreplacedatacountnegative.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrreplacedatacountnegative"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrReplaceDataCountNegative</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified count |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its |
| "replaceData(offset,count,arg) method with offset=10 |
| and count=-3 and arg="ABC". It should raise the |
| desired exception since the count is negative. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6531BCCF')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="badString" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <substringData var="badString" obj="child" offset="10" count="-3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrreplacedataoffsetgreater.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrreplacedataoffsetgreater"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrReplaceDataOffsetGreater</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is greater than the length of the string. |
| Retrieve the character data of the last child of the |
| first employee and invoke its |
| "replaceData(offset,count,arg) method with offset=40 |
| and count=3 and arg="ABC". It should raise the |
| desired exception since the offset is greater than the |
| length of the string. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-7C603781"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-7C603781')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=242"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throw_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <deleteData obj="child" offset="40" count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrreplacedataoffsetnegative.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrreplacedataoffsetnegative"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrReplaceDataOffsetNegative</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its |
| "replaceData(offset,count,arg) method with offset=-5 |
| and count=3 and arg="ABC". It should raise the |
| desired exception since the offset is negative. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-E5CBA7FB')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <replaceData obj="child" offset="-5" count="3" arg='"ABC"'/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrsubstringcountnegative.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrsubstringcountnegative"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrSubstringCountNegative</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "substringData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified count |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "substringData(offset,count) |
| method with offset=10 and count=-3. It should raise the |
| desired exception since the count is negative. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6531BCCF')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="badSubstring" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <substringData var="badSubstring" obj="child" offset="10" count="-3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrsubstringnegativeoffset.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrsubstringnegativeoffset"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrSubstringNegativeOffset</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "substringData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is negative. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "substringData(offset,count) |
| method with offset=-5 and count=3. It should raise the |
| desired exception since the offset is negative. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6531BCCF')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="badString" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <substringData var="badString" obj="child" offset="-5" count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdataindexsizeerrsubstringoffsetgreater.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdataindexsizeerrsubstringoffsetgreater"> |
| <metadata> |
| <title>hc_characterdataIndexSizeErrSubstringOffsetGreater</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "substringData(offset,count)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset |
| is greater than the number of characters in the string. |
| Retrieve the character data of the last child of the |
| first employee and invoke its "substringData(offset,count) |
| method with offset=40 and count=3. It should raise the |
| desired exception since the offsets value is greater |
| than the length. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-6531BCCF')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="badString" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <assertDOMException id="throw_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <substringData var="badString" obj="child" offset="40" count="3"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatainsertdatabeginning.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatainsertdatabeginning"> |
| <metadata> |
| <title>hc_characterdataInsertDataBeginning</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertData(offset,arg)" method will insert a string |
| at the specified character offset. Insert the data at |
| the beginning of the character data. |
| Retrieve the character data from the second child of |
| the first employee. The "insertData(offset,arg)" |
| method is then called with offset=0 and arg="Mss.". |
| The method should insert the string "Mss." at position 0. |
| The new value of the character data should be |
| "Mss. Margaret Martin". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--insertData--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3EDB695F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <insertData obj="child" offset="0" arg='"Mss. "'/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"Mss. Margaret Martin"' id="characterdataInsertDataBeginningAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatainsertdataend.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatainsertdataend"> |
| <metadata> |
| <title>hc_characterdataInsertDataEnd</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertData(offset,arg)" method will insert a string |
| at the specified character offset. Insert the data at |
| the end of the character data. |
| Retrieve the character data from the second child of |
| the first employee. The "insertData(offset,arg)" |
| method is then called with offset=15 and arg=", Esquire". |
| The method should insert the string ", Esquire" at |
| position 15. The new value of the character data should |
| be "Margaret Martin, Esquire". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3EDB695F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <insertData obj="child" offset="15" arg='", Esquire"'/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"Margaret Martin, Esquire"' id="characterdataInsertDataEndAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatainsertdatamiddle.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatainsertdatamiddle"> |
| <metadata> |
| <title>hc_characterdataInsertDataMiddle</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertData(offset,arg)" method will insert a string |
| at the specified character offset. Insert the data in |
| the middle of the character data. |
| Retrieve the character data from the second child of |
| the first employee. The "insertData(offset,arg)" |
| method is then called with offset=9 and arg="Ann". |
| The method should insert the string "Ann" at position 9. |
| The new value of the character data should be |
| "Margaret Ann Martin". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3EDB695F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <insertData obj="child" offset="9" arg='"Ann "'/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"Margaret Ann Martin"' id="characterdataInsertDataMiddleAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatareplacedatabegining.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatareplacedatabegining"> |
| <metadata> |
| <title>hc_characterdataReplaceDataBeginning</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method replaces the |
| characters starting at the specified offset with the |
| specified string. Test for replacement in the |
| middle of the data. |
| Retrieve the character data from the last child of the |
| first employee. The "replaceData(offset,count,arg)" |
| method is then called with offset=5 and count=5 and |
| arg="South". The method should replace characters five |
| thru 9 of the character data with "South". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--replaceData--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <replaceData obj="child" offset="0" count="4" arg='"2500"'/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"2500 North Ave. Dallas, Texas 98551"' id="characterdataReplaceDataBeginingAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatareplacedataend.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatareplacedataend"> |
| <metadata> |
| <title>hc_characterdataReplaceDataEnd</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method replaces the |
| characters starting at the specified offset with the |
| specified string. Test for replacement at the |
| end of the data. |
| Retrieve the character data from the last child of the |
| first employee. The "replaceData(offset,count,arg)" |
| method is then called with offset=30 and count=5 and |
| arg="98665". The method should replace characters 30 |
| thru 34 of the character data with "98665". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <replaceData obj="child" offset="30" count="5" arg='"98665"'/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"1230 North Ave. Dallas, Texas 98665"' id="characterdataReplaceDataEndAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatareplacedataexceedslengthofarg.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatareplacedataexceedslengthofarg"> |
| <metadata> |
| <title>hc_characterdataReplaceDataExceedsLengthOfArg</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method replaces the |
| characters starting at the specified offset with the |
| specified string. Test the situation where the length |
| of the arg string is greater than the specified offset. |
| Retrieve the character data from the last child of the |
| first employee. The "replaceData(offset,count,arg)" |
| method is then called with offset=0 and count=4 and |
| arg="260030". The method should replace characters one |
| thru four with "260030". Note that the length of the |
| specified string is greater that the specified offset. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <replaceData obj="child" offset="0" count="4" arg='"260030"'/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"260030 North Ave. Dallas, Texas 98551"' id="characterdataReplaceDataExceedsLengthOfArgAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatareplacedataexceedslengthofdata.xml.kfail |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatareplacedataexceedslengthofdata"> |
| <metadata> |
| <title>hc_characterdataReplaceDataExceedsLengthOfData</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the sum of the offset and count exceeds the length then |
| all the characters to the end of the data are replaced. |
| Retrieve the character data from the last child of the |
| first employee. The "replaceData(offset,count,arg)" |
| method is then called with offset=0 and count=50 and |
| arg="2600". The method should replace all the characters |
| with "2600". This is because the sum of the offset and |
| count exceeds the length of the character data. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <replaceData obj="child" offset="0" count="50" arg='"2600"'/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"2600"' id="characterdataReplaceDataExceedsLengthOfDataAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatareplacedatamiddle.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatareplacedatamiddle"> |
| <metadata> |
| <title>hc_characterdataReplaceDataMiddle</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceData(offset,count,arg)" method replaces the |
| characters starting at the specified offset with the |
| specified string. Test for replacement in the |
| middle of the data. |
| Retrieve the character data from the last child of the |
| first employee. The "replaceData(offset,count,arg)" |
| method is then called with offset=5 and count=5 and |
| arg="South". The method should replace characters five |
| thru 9 of the character data with "South". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E5CBA7FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <replaceData obj="child" offset="5" count="5" arg='"South"'/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"1230 South Ave. Dallas, Texas 98551"' id="characterdataReplaceDataMiddleAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatasetnodevalue.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatasetnodevalue"> |
| <metadata> |
| <title>hc_characterdataSetNodeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setNodeValue()" method changes the character data |
| currently stored in the node. |
| Retrieve the character data from the second child |
| of the first employee and invoke the "setNodeValue()" |
| method, call "getData()" and compare. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-72AB8359"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="childData" type="DOMString"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <nodeValue obj="child" value='"Marilyn Martin"'/> |
| <data interface="CharacterData" obj="child" var="childData"/> |
| <assertEquals actual="childData" expected='"Marilyn Martin"' id="data" ignoreCase="false"/> |
| <nodeValue obj="child" var="childValue"/> |
| <assertEquals actual="childValue" expected='"Marilyn Martin"' id="value" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatasubstringexceedsvalue.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatasubstringexceedsvalue"> |
| <metadata> |
| <title>hc_characterdataSubStringExceedsValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the sum of the "offset" and "count" exceeds the |
| "length" then the "substringData(offset,count)" method |
| returns all the characters to the end of the data. |
| Retrieve the character data from the second child |
| of the first employee and access part of the data |
| by using the substringData(offset,count) method |
| with offset=9 and count=10. The method should return |
| the substring "Martin" since offset+count > length |
| (19 > 15). |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--CharacterData.substringData--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="substring" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <substringData obj="child" var="substring" offset="9" count="10"/> |
| <assertEquals actual="substring" expected='"Martin"' id="characterdataSubStringExceedsValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_characterdatasubstringvalue.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_characterdatasubstringvalue"> |
| <metadata> |
| <title>hc_characterdataSubStringValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "substringData(offset,count)" method returns the |
| specified string. |
| Retrieve the character data from the second child |
| of the first employee and access part of the data |
| by using the substringData(offset,count) method. The |
| method should return the specified substring starting |
| at position "offset" and extract "count" characters. |
| The method should return the string "Margaret". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--CharacterData.substringData--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6531BCCF"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="child" type="CharacterData"/> |
| <var name="substring" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="nameNode"/> |
| <firstChild interface="Node" obj="nameNode" var="child"/> |
| <substringData obj="child" var="substring" offset="0" count="8"/> |
| <assertEquals actual="substring" expected='"Margaret"' id="characterdataSubStringValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_commentgetcomment.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_commentgetcomment"> |
| <metadata> |
| <title>hc_commentgetcomment</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| A comment is all the characters between the starting |
| '<!--' and ending '-->' |
| Retrieve the nodes of the DOM document. Search for a |
| comment node and the content is its value. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!-- Comment interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1334481328"/> |
| <!--Node.nodeName attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <!--Node.nodeValue attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <!--Node.nodeType attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=509"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="commentCount" type="int" value="0"/> |
| <var name="childType" type="int"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <childNodes obj="doc" var="elementList"/> |
| <for-each collection="elementList" member="child"> |
| <nodeType obj="child" var="childType"/> |
| <if> |
| <equals actual="childType" expected="8" ignoreCase="false"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"#comment"' ignoreCase="false" id="nodeName"/> |
| <nodeValue obj="child" var="childValue"/> |
| <assertEquals actual="childValue" expected='" This is comment number 1."' id="nodeValue" ignoreCase="false"/> |
| <attributes var="attributes" obj="child"/> |
| <assertNull actual="attributes" id="attributes"/> |
| <increment var="commentCount" value="1"/> |
| </if> |
| </for-each> |
| <assertTrue id="atMostOneComment"><less actual="commentCount" expected="2"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentcreateattribute.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentcreateattribute"> |
| <metadata> |
| <title>hc_documentcreateattribute</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the entire DOM document and invoke its |
| "createAttribute(name)" method. It should create a |
| new Attribute node with the given name. The name, value |
| and type of the newly created object are retrieved and |
| output. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1084891198"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Jun/0011.html"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newAttrNode" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="attrType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttribute obj="doc" var="newAttrNode" name='"title"'/> |
| <nodeValue obj="newAttrNode" var="attrValue"/> |
| <assertEquals actual="attrValue" expected='""' ignoreCase="false" id="value"/> |
| <nodeName obj="newAttrNode" var="attrName"/> |
| <assertEquals actual="attrName" expected='"title"' ignoreCase="auto" context="attribute" id="name"/> |
| <nodeType obj="newAttrNode" var="attrType"/> |
| <assertEquals actual="attrType" expected="2" ignoreCase="false" id="type"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentcreatecomment.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentcreatecomment"> |
| <metadata> |
| <title>hc_documentCreateComment</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "createComment(data)" method creates a new Comment |
| node given the specified string. |
| Retrieve the entire DOM document and invoke its |
| "createComment(data)" method. It should create a new |
| Comment node whose "data" is the specified string. |
| The content, name and type are retrieved and output. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1334481328"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newCommentNode" type="Comment"/> |
| <var name="newCommentValue" type="DOMString"/> |
| <var name="newCommentName" type="DOMString"/> |
| <var name="newCommentType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createComment obj="doc" var="newCommentNode" data='"This is a new Comment node"'/> |
| <nodeValue obj="newCommentNode" var="newCommentValue"/> |
| <assertEquals actual="newCommentValue" expected='"This is a new Comment node"' ignoreCase="false" id="value"/> |
| <nodeName obj="newCommentNode" var="newCommentName"/> |
| <assertEquals actual="newCommentName" expected='"#comment"' ignoreCase="false" id="strong"/> |
| <nodeType obj="newCommentNode" var="newCommentType"/> |
| <assertEquals actual="newCommentType" expected="8" ignoreCase="false" id="type"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentcreatedocumentfragment.xml.int-broken |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentcreatedocumentfragment"> |
| <metadata> |
| <title>hc_documentCreateDocumentFragment</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "createDocumentFragment()" method creates an empty |
| DocumentFragment object. |
| Retrieve the entire DOM document and invoke its |
| "createDocumentFragment()" method. The content, name, |
| type and value of the newly created object are output. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-35CB04B5"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDocFragment" type="DocumentFragment"/> |
| <var name="children" type="NodeList"/> |
| <var name="length" type="int"/> |
| <var name="newDocFragmentName" type="DOMString"/> |
| <var name="newDocFragmentType" type="int"/> |
| <var name="newDocFragmentValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="newDocFragment"/> |
| <childNodes obj="newDocFragment" var="children"/> |
| <length interface="NodeList" obj="children" var="length"/> |
| <assertEquals actual="length" expected="0" ignoreCase="false" id="length"/> |
| <nodeName obj="newDocFragment" var="newDocFragmentName"/> |
| <assertEquals actual="newDocFragmentName" expected='"#document-fragment"' ignoreCase="false" id="strong"/> |
| <nodeType obj="newDocFragment" var="newDocFragmentType"/> |
| <assertEquals actual="newDocFragmentType" expected="11" ignoreCase="false" id="type"/> |
| <nodeValue obj="newDocFragment" var="newDocFragmentValue"/> |
| <assertNull actual="newDocFragmentValue" id="value"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentcreateelement.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentcreateelement"> |
| <metadata> |
| <title>hc_documentCreateElement</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "createElement(tagName)" method creates an Element |
| of the type specified. |
| Retrieve the entire DOM document and invoke its |
| "createElement(tagName)" method with tagName="acronym". |
| The method should create an instance of an Element node |
| whose tagName is "acronym". The NodeName, NodeType |
| and NodeValue are returned. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newElement" type="Element"/> |
| <var name="newElementName" type="DOMString"/> |
| <var name="newElementType" type="int"/> |
| <var name="newElementValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElement obj="doc" var="newElement" tagName='"acronym"'/> |
| <nodeName obj="newElement" var="newElementName"/> |
| <assertEquals actual="newElementName" expected='"acronym"' ignoreCase="auto" id="strong"/> |
| <nodeType obj="newElement" var="newElementType"/> |
| <assertEquals actual="newElementType" expected="1" ignoreCase="false" id="type"/> |
| <nodeValue obj="newElement" var="newElementValue"/> |
| <assertNull actual="newElementValue" id="valueInitiallyNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentcreateelementcasesensitive.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentcreateelementcasesensitive"> |
| <metadata> |
| <title>hc_documentCreateElementCaseSensitive</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The tagName parameter in the "createElement(tagName)" |
| method is case-sensitive for XML documents. |
| Retrieve the entire DOM document and invoke its |
| "createElement(tagName)" method twice. Once for tagName |
| equal to "acronym" and once for tagName equal to "ACRONYM" |
| Each call should create a distinct Element node. The |
| newly created Elements are then assigned attributes |
| that are retrieved. |
| Modified on 27 June 2003 to avoid setting an invalid style |
| values and checked the node names to see if they matched expectations. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newElement1" type="Element"/> |
| <var name="newElement2" type="Element"/> |
| <var name="attribute1" type="DOMString"/> |
| <var name="attribute2" type="DOMString"/> |
| <var name="nodeName1" type="DOMString"/> |
| <var name="nodeName2" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElement obj="doc" var="newElement1" tagName='"ACRONYM"'/> |
| <createElement obj="doc" var="newElement2" tagName='"acronym"'/> |
| <setAttribute obj="newElement1" name='"lang"' value='"EN"'/> |
| <setAttribute obj="newElement2" name='"title"' value='"Dallas"'/> |
| <getAttribute obj="newElement1" var="attribute1" name='"lang"'/> |
| <getAttribute obj="newElement2" var="attribute2" name='"title"'/> |
| <assertEquals actual="attribute1" expected='"EN"' ignoreCase="false" id="attrib1"/> |
| <assertEquals actual="attribute2" expected='"Dallas"' ignoreCase="false" id="attrib2"/> |
| <nodeName var="nodeName1" obj="newElement1"/> |
| <nodeName var="nodeName2" obj="newElement2"/> |
| <assertEquals actual="nodeName1" expected='"ACRONYM"' ignoreCase="auto" id="nodeName1"/> |
| <assertEquals actual="nodeName2" expected='"acronym"' ignoreCase="auto" id="nodeName2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentcreatetextnode.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentcreatetextnode"> |
| <metadata> |
| <title>hc_documentCreateTextNode</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "createTextNode(data)" method creates a Text node |
| given the specfied string. |
| Retrieve the entire DOM document and invoke its |
| "createTextNode(data)" method. It should create a |
| new Text node whose "data" is the specified string. |
| The NodeName and NodeType are also checked. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1975348127"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newTextNode" type="Text"/> |
| <var name="newTextName" type="DOMString"/> |
| <var name="newTextValue" type="DOMString"/> |
| <var name="newTextType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createTextNode obj="doc" var="newTextNode" data='"This is a new Text node"'/> |
| <nodeValue obj="newTextNode" var="newTextValue"/> |
| <assertEquals actual="newTextValue" expected='"This is a new Text node"' ignoreCase="false" id="value"/> |
| <nodeName obj="newTextNode" var="newTextName"/> |
| <assertEquals actual="newTextName" expected='"#text"' ignoreCase="false" id="strong"/> |
| <nodeType obj="newTextNode" var="newTextType"/> |
| <assertEquals actual="newTextType" expected="3" ignoreCase="false" id="type"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentgetdoctype.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentgetdoctype"> |
| <metadata> |
| <title>hc_documentgetdoctype</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Access Document.doctype for hc_staff, if not text/html should return DocumentType node. |
| HTML implementations may return null. |
| </description> |
| <date qualifier="created">2004-01-27</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A31"/> |
| <!-- TODO: link to errata --> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="docTypeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| </if> |
| <if><notNull obj="docType"/> |
| <name interface="DocumentType" obj="docType" var="docTypeName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="docTypeName" expected='"svg"' id="nodeNameSVG" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="docTypeName" expected='"html"' id="nodeName" ignoreCase="false"/> |
| </else> |
| </if> |
| <nodeValue obj="docType" var="nodeValue"/> |
| <assertNull actual="nodeValue" id="nodeValue"/> |
| <attributes var="attributes" obj="docType"/> |
| <assertNull actual="attributes" id="attributes"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentgetelementsbytagnamelength.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentgetelementsbytagnamelength"> |
| <metadata> |
| <title>hc_documentGetElementsByTagNameLength</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagName(tagName)" method returns a |
| NodeList of all the Elements with a given tagName. |
| Retrieve the entire DOM document and invoke its |
| "getElementsByTagName(tagName)" method with tagName |
| equal to "strong". The method should return a NodeList |
| that contains 5 elements. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-A6C9094"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nameList" tagname='"strong"'/> |
| <assertSize collection="nameList" size="5" id="documentGetElementsByTagNameLengthAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentgetelementsbytagnametotallength.xml |
|---|
| 0,0 → 1,135 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentgetelementsbytagnametotallength"> |
| <metadata> |
| <title>hc_documentgetelementsbytagnametotallength</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the entire DOM document and invoke its |
| "getElementsByTagName(tagName)" method with tagName |
| equal to "*". The method should return a NodeList |
| that contains all the elements of the document. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-A6C9094"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=251"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <var name="expectedNames" type="List"> |
| <member>"html"</member> |
| <member>"head"</member> |
| <member>"meta"</member> |
| <member>"title"</member> |
| <member>"script"</member> |
| <member>"script"</member> |
| <member>"script"</member> |
| <member>"body"</member> |
| <member>"p"</member> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"p"</member> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"p"</member> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"p"</member> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"p"</member> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| </var> |
| <var name="svgExpectedNames" type="List"> |
| <member>"svg"</member> |
| <member>"rect"</member> |
| <member>"script"</member> |
| <member>"head"</member> |
| <member>"meta"</member> |
| <member>"title"</member> |
| <member>"body"</member> |
| <member>"p"</member> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"p"</member> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"p"</member> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"p"</member> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"p"</member> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| </var> |
| <var name="actualNames" type="List"/> |
| <var name="thisElement" type="Element"/> |
| <var name="thisTag" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nameList" tagname='"*"'/> |
| <for-each collection="nameList" member="thisElement"> |
| <tagName var="thisTag" obj="thisElement"/> |
| <append collection="actualNames" item="thisTag"/> |
| </for-each> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals expected="svgExpectedNames" actual="actualNames" ignoreCase="auto" id="svgTagNames"/> |
| <else> |
| <assertEquals expected="expectedNames" actual="actualNames" ignoreCase="auto" id="tagNames"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentgetelementsbytagnamevalue.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentgetelementsbytagnamevalue"> |
| <metadata> |
| <title>hc_documentGetElementsByTagNameValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagName(tagName)" method returns a |
| NodeList of all the Elements with a given tagName |
| in a pre-order traversal of the tree. |
| Retrieve the entire DOM document and invoke its |
| "getElementsByTagName(tagName)" method with tagName |
| equal to "strong". The method should return a NodeList |
| that contains 5 elements. The FOURTH item in the |
| list is retrieved and output. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-A6C9094"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nameList" tagname='"strong"'/> |
| <item interface="NodeList" obj="nameList" var="nameNode" index="3"/> |
| <firstChild interface="Node" obj="nameNode" var="firstChild"/> |
| <nodeValue obj="firstChild" var="childValue"/> |
| <assertEquals actual="childValue" expected='"Jeny Oconnor"' id="documentGetElementsByTagNameValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentgetimplementation.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentgetimplementation"> |
| <metadata> |
| <title>hc_documentgetimplementation</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the entire DOM document and invoke its |
| "getImplementation()" method. If contentType="text/html", |
| DOMImplementation.hasFeature("HTML","1.0") should be true. |
| Otherwise, DOMImplementation.hasFeature("XML", "1.0") |
| should be true. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1B793EBA"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=245"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docImpl" type="DOMImplementation"/> |
| <var name="xmlstate" type="boolean"/> |
| <var name="htmlstate" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation obj="doc" var="docImpl"/> |
| <hasFeature obj="docImpl" var="xmlstate" feature='"XML"' version='"1.0"'/> |
| <hasFeature obj="docImpl" var="htmlstate" feature='"HTML"' version='"1.0"'/> |
| <if><contentType type="text/html"/> |
| <assertTrue actual="htmlstate" id="supports_HTML_1.0"/> |
| <else> |
| <assertTrue actual="xmlstate" id="supports_XML_1.0"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentgetrootnode.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentgetrootnode"> |
| <metadata> |
| <title>hc_documentgetrootnode</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document and invoke its |
| "getDocumentElement()" method. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--documentElement attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-87CD092"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=251"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="root" type="Element"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <nodeName obj="root" var="rootName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="rootName" expected='"svg"' id="svgTagName" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="rootName" expected='"html"' id="docElemName" ignoreCase="auto"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentinvalidcharacterexceptioncreateattribute.xml.not-for-html5 |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentinvalidcharacterexceptioncreateattribute"> |
| <metadata> |
| <title>hc_documentInvalidCharacterExceptionCreateAttribute</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "createAttribute(tagName)" method raises an |
| INVALID_CHARACTER_ERR DOMException if the specified |
| tagName contains an invalid character. |
| Retrieve the entire DOM document and invoke its |
| "createAttribute(tagName)" method with the tagName equal |
| to the string "invalid^Name". Due to the invalid |
| character the desired EXCEPTION should be raised. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1084891198"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1084891198')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1084891198"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="createdAttr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createAttribute var="createdAttr" obj="doc" name='"invalid^Name"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentinvalidcharacterexceptioncreateattribute1.xml.not-for-html5 |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentinvalidcharacterexceptioncreateattribute1"> |
| <metadata> |
| <title>hc_documentinvalidcharacterexceptioncreateattribute1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Creating an attribute with an empty name should cause an INVALID_CHARACTER_ERR. |
| </description> |
| <date qualifier="created">2004-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1084891198"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1084891198')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1084891198"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=525"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="createdAttr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createAttribute var="createdAttr" obj="doc" name='""'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentinvalidcharacterexceptioncreateelement.xml.not-for-html5 |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentinvalidcharacterexceptioncreateelement"> |
| <metadata> |
| <title>hc_documentInvalidCharacterExceptionCreateElement</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "createElement(tagName)" method raises an |
| INVALID_CHARACTER_ERR DOMException if the specified |
| tagName contains an invalid character. |
| Retrieve the entire DOM document and invoke its |
| "createElement(tagName)" method with the tagName equal |
| to the string "invalid^Name". Due to the invalid |
| character the desired EXCEPTION should be raised. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-2141741547')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="badElement" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createElement var="badElement" obj="doc" tagName='"invalid^Name"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_documentinvalidcharacterexceptioncreateelement1.xml.not-for-html5 |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_documentinvalidcharacterexceptioncreateelement1"> |
| <metadata> |
| <title>hc_documentinvalidcharacterexceptioncreateelement1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Creating an element with an empty name should cause an INVALID_CHARACTER_ERR. |
| </description> |
| <date qualifier="created">2004-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-2141741547')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-2141741547"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=525"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="badElement" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createElement var="badElement" obj="doc" tagName='""'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_domimplementationfeaturenoversion.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_domimplementationfeaturenoversion"> |
| <metadata> |
| <title>hc_domimplementationfeaturenoversion</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document and invoke its |
| "getImplementation()" method. This should create a |
| DOMImplementation object whose "hasFeature(feature, |
| version)" method is invoked with version equal to "". |
| If the version is not specified, supporting any version |
| feature will cause the method to return "true". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-5CED94D7"/> |
| <subject resource="http://www.w3.org/2000/11/DOM-Level-2-errata#core-14"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=245"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <if><contentType type="text/html"/> |
| <hasFeature obj="domImpl" var="state" feature='"HTML"' version='""'/> |
| <else> |
| <hasFeature obj="domImpl" var="state" feature='"XML"' version='""'/> |
| </else> |
| </if> |
| <assertTrue actual="state" id="hasFeatureBlank"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_domimplementationfeaturenull.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_domimplementationfeaturenull"> |
| <metadata> |
| <title>hc_domimplementationfeaturenull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document and invoke its |
| "getImplementation()" method. This should create a |
| DOMImplementation object whose "hasFeature(feature, |
| version)" method is invoked with version equal to null. |
| If the version is not specified, supporting any version |
| feature will cause the method to return "true". |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-5CED94D7"/> |
| <subject resource="http://www.w3.org/2000/11/DOM-Level-2-errata#core-14"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=245"/> |
| </metadata> |
| <implementationAttribute name="hasNullString" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <!-- version (omitted) = null --> |
| <if><contentType type="text/html"/> |
| <hasFeature obj="domImpl" var="state" feature='"HTML"'/> |
| <assertTrue actual="state" id="supports_HTML_null"/> |
| <else> |
| <hasFeature obj="domImpl" var="state" feature='"XML"'/> |
| <assertTrue actual="state" id="supports_XML_null"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_domimplementationfeaturexml.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_domimplementationfeaturexml"> |
| <metadata> |
| <title>hc_domimplementationfeaturexml</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the entire DOM document and invoke its |
| "getImplementation()" method. This should create a |
| DOMImplementation object whose "hasFeature(feature, |
| version)" method is invoked with "feature" equal to "html" or "xml". |
| The method should return a boolean "true". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-5CED94D7"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=245"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <if><contentType type="text/html"/> |
| <hasFeature obj="domImpl" var="state" feature='"html"' version='"1.0"'/> |
| <assertTrue actual="state" id="supports_html_1.0"/> |
| <else> |
| <hasFeature obj="domImpl" var="state" feature='"xml"' version='"1.0"'/> |
| <assertTrue actual="state" id="supports_xml_1.0"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementaddnewattribute.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementaddnewattribute"> |
| <metadata> |
| <title>hc_elementAddNewAttribute</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setAttribute(name,value)" method adds a new attribute |
| to the Element |
| Retrieve the last child of the last employee, then |
| add an attribute to it by invoking the |
| "setAttribute(name,value)" method. It should create |
| a "strong" attribute with an assigned value equal to |
| "value". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--setAttribute--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="4" var="testEmployee"/> |
| <setAttribute obj="testEmployee" name='"lang"' value='"EN-us"'/> |
| <getAttribute obj="testEmployee" var="attrValue" name='"lang"'/> |
| <assertEquals actual="attrValue" expected='"EN-us"' id="attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementassociatedattribute.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementassociatedattribute"> |
| <metadata> |
| <title>hc_elementAssociatedAttribute</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the first attribute from the last child of |
| the first employee and invoke the "getSpecified()" |
| method. This test is only intended to show that |
| Elements can actually have attributes. This test uses |
| the "getNamedItem(name)" method from the NamedNodeMap |
| interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="specified" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name='"title"'/> |
| <specified obj="domesticAttr" var="specified"/> |
| <assertTrue actual="specified" id="acronymTitleSpecified"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementchangeattributevalue.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementchangeattributevalue"> |
| <metadata> |
| <title>hc_elementChangeAttributeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setAttribute(name,value)" method adds a new attribute |
| to the Element. If the "strong" is already present, then |
| its value should be changed to the new one that is in |
| the "value" parameter. |
| Retrieve the last child of the fourth employee, then add |
| an attribute to it by invoking the |
| "setAttribute(name,value)" method. Since the name of the |
| used attribute("class") is already present in this |
| element, then its value should be changed to the new one |
| of the "value" parameter. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--setAttribute--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="3" var="testEmployee"/> |
| <setAttribute obj="testEmployee" name='"class"' value='"Neither"'/> |
| <getAttribute obj="testEmployee" var="attrValue" name='"class"'/> |
| <assertEquals actual="attrValue" expected='"Neither"' id="elementChangeAttributeValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementcreatenewattribute.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementcreatenewattribute"> |
| <metadata> |
| <title>hc_elementCreateNewAttribute</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method adds a new |
| attribute to the Element. |
| Retrieve first address element and add |
| a new attribute node to it by invoking its |
| "setAttributeNode(newAttr)" method. This test makes use |
| of the "createAttribute(name)" method from the Document |
| interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--setAttributeNode--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="oldAttr" type="Attr"/> |
| <var name="districtAttr" type="Attr"/> |
| <var name="attrVal" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddress"/> |
| <createAttribute obj="doc" var="newAttribute" name='"lang"'/> |
| <setAttributeNode obj="testAddress" var="oldAttr" newAttr="newAttribute"/> |
| <assertNull actual="oldAttr" id="old_attr_doesnt_exist"/> |
| <getAttributeNode obj="testAddress" var="districtAttr" name='"lang"'/> |
| <assertNotNull actual="districtAttr" id="new_district_accessible"/> |
| <getAttribute var="attrVal" obj="testAddress" name='"lang"'/> |
| <assertEquals actual="attrVal" expected='""' id="attr_value" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementgetattributenode.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementgetattributenode"> |
| <metadata> |
| <title>hc_elementgetattributenode</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the attribute "title" from the last child |
| of the first "p" element and check its node name. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-217A91B8"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Jun/0011.html"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="nodeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <getAttributeNode obj="testEmployee" var="domesticAttr" name='"title"'/> |
| <nodeName obj="domesticAttr" var="nodeName"/> |
| <assertEquals actual="nodeName" expected='"title"' id="nodeName" ignoreCase="auto" context="attribute"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementgetattributenodenull.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementgetattributenodenull"> |
| <metadata> |
| <title>hc_elementGetAttributeNodeNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getAttributeNode(name)" method retrieves an |
| attribute node by name. It should return null if the |
| "strong" attribute does not exist. |
| Retrieve the last child of the first employee and attempt |
| to retrieve a non-existing attribute. The method should |
| return "null". The non-existing attribute to be used |
| is "invalidAttribute". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-217A91B8"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="domesticAttr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <getAttributeNode obj="testEmployee" var="domesticAttr" name='"invalidAttribute"'/> |
| <assertNull actual="domesticAttr" id="elementGetAttributeNodeNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementgetelementempty.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementgetelementempty"> |
| <metadata> |
| <title>hc_elementGetElementEmpty</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getAttribute(name)" method returns an empty |
| string if no value was assigned to an attribute and |
| no default value was given in the DTD file. |
| Retrieve the last child of the last employee, then |
| invoke "getAttribute(name)" method, where "strong" is an |
| attribute without a specified or DTD default value. |
| The "getAttribute(name)" method should return the empty |
| string. This method makes use of the |
| "createAttribute(newAttr)" method from the Document |
| interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--getAttribute--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-666EE0F9"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttribute obj="doc" var="newAttribute" name='"lang"'/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="3" var="testEmployee"/> |
| <setAttributeNode obj="testEmployee" var="domesticAttr" newAttr="newAttribute"/> |
| <getAttribute obj="testEmployee" var="attrValue" name='"lang"'/> |
| <assertEquals actual="attrValue" expected='""' id="elementGetElementEmptyAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementgetelementsbytagname.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementgetelementsbytagname"> |
| <metadata> |
| <title>hc_elementGetElementsByTagName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagName(name)" method returns a list |
| of all descendant Elements with the given tag name. |
| Test for an empty list. |
| Create a NodeList of all the descendant elements |
| using the string "noMatch" as the tagName. |
| The method should return a NodeList whose length is |
| "0" since there are not any descendant elements |
| that match the given tag name. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--getElementsByTagName--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1938918D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <assertSize collection="elementList" size="5" id="elementGetElementsByTagNameAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementgetelementsbytagnameaccessnodelist.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementgetelementsbytagnameaccessnodelist"> |
| <metadata> |
| <title>hc_elementGetElementsByTagName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagName(name)" method returns a list |
| of all descendant Elements in the order the children |
| were encountered in a pre order traversal of the element |
| tree. |
| Create a NodeList of all the descendant elements |
| using the string "p" as the tagName. |
| The method should return a NodeList whose length is |
| "5" in the order the children were encountered. |
| Access the FOURTH element in the NodeList. The FOURTH |
| element, the first or second should be an "em" node with |
| the content "EMP0004". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--getElementsByTagName--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1938918D"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="firstC" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="employeeIDNode" type="CharacterData"/> |
| <var name="employeeID" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="3" var="testEmployee"/> |
| <firstChild interface="Node" obj="testEmployee" var="firstC"/> |
| <nodeType var="nodeType" obj="firstC"/> |
| <!-- if a text node, get the next sibling --> |
| <while><equals actual="nodeType" expected="3"/> |
| <nextSibling interface="Node" var="firstC" obj="firstC"/> |
| <nodeType var="nodeType" obj="firstC"/> |
| </while> |
| <nodeName obj="firstC" var="childName"/> |
| <assertEquals actual="childName" expected='"em"' id="childName" ignoreCase="auto"/> |
| <firstChild interface="Node" var="employeeIDNode" obj="firstC"/> |
| <nodeValue var="employeeID" obj="employeeIDNode"/> |
| <assertEquals actual="employeeID" expected='"EMP0004"' ignoreCase="false" id="employeeID"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementgetelementsbytagnamenomatch.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementgetelementsbytagnamenomatch"> |
| <metadata> |
| <title>hc_elementGetElementsByTagName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagName(name)" method returns a list |
| of all descendant Elements with the given tag name. |
| Create a NodeList of all the descendant elements |
| using the string "employee" as the tagName. |
| The method should return a NodeList whose length is |
| "5". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--getElementsByTagName--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1938918D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"noMatch"' var="elementList"/> |
| <assertSize collection="elementList" size="0" id="elementGetElementsByTagNameNoMatchNoMatchAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementgetelementsbytagnamespecialvalue.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementgetelementsbytagnamespecialvalue"> |
| <metadata> |
| <title>hc_elementGetElementsByTagNamesSpecialValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagName(name)" method may use the |
| special value "*" to match all tags in the element |
| tree. |
| Create a NodeList of all the descendant elements |
| of the last employee by using the special value "*". |
| The method should return all the descendant children(6) |
| in the order the children were encountered. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1938918D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="lastEmployee" type="Element"/> |
| <var name="lastempList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="expectedResult" type="List"> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="4" var="lastEmployee"/> |
| <getElementsByTagName interface="Element" obj="lastEmployee" var="lastempList" tagname='"*"'/> |
| <for-each collection="lastempList" member="child"> |
| <nodeName obj="child" var="childName"/> |
| <append collection="result" item="childName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedResult" id="tagNames" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementgettagname.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementgettagname"> |
| <metadata> |
| <title>hc_elementgettagname</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Invoke the "getTagName()" method one the |
| root node. The value returned should be "html" or "svg". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-104682815"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=251"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="root" type="Element"/> |
| <var name="tagname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <tagName obj="root" var="tagname"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="tagname" expected='"svg"' id="svgTagname" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="tagname" expected='"html"' id="tagname" ignoreCase="auto"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementinuseattributeerr.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementinuseattributeerr"> |
| <metadata> |
| <title>hc_elementInUseAttributeErr</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method raises an |
| "INUSE_ATTRIBUTE_ERR DOMException if the "newAttr" |
| is already an attribute of another element. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-887236154')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=244"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="addressElementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <var name="newElement" type="Element"/> |
| <var name="attrAddress" type="Attr"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="setAttr1" type="Attr"/> |
| <var name="setAttr2" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"body"' var="addressElementList"/> |
| <item interface="NodeList" obj="addressElementList" index="0" var="testAddress"/> |
| <createElement obj="doc" var="newElement" tagName='"p"'/> |
| <appendChild var="appendedChild" obj="testAddress" newChild="newElement"/> |
| <createAttribute obj="doc" var="newAttribute" name='"title"'/> |
| <setAttributeNode var="setAttr1" obj="newElement" newAttr="newAttribute"/> |
| <assertDOMException id="throw_INUSE_ATTRIBUTE_ERR"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setAttributeNode var="setAttr2" obj="testAddress" newAttr="newAttribute"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementinvalidcharacterexception.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementinvalidcharacterexception"> |
| <metadata> |
| <title>hc_elementInvalidCharacterException</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setAttribute(name,value)" method raises an |
| "INVALID_CHARACTER_ERR DOMException if the specified |
| name contains an invalid character. |
| Retrieve the last child of the first employee and |
| call its "setAttribute(name,value)" method with |
| "strong" containing an invalid character. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-F68F082')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddress"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <setAttribute obj="testAddress" name='"invalid^Name"' value='"value"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementinvalidcharacterexception1.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementinvalidcharacterexception1"> |
| <metadata> |
| <title>hc_elementinvalidcharacterexception1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Calling Element.setAttribute with an empty name will cause an INVALID_CHARACTER_ERR. |
| </description> |
| <date qualifier="created">2004-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68F082"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-F68F082')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=525"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""acronym"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddress"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <setAttribute obj="testAddress" name='""' value=""value""/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementnormalize.xml.notimpl |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementnormalize"> |
| <metadata> |
| <title>hc_elementnormalize</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Append a couple of text nodes to the first sup element, normalize the |
| document element and check that the element has been normalized. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-162CF083"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=546"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="root" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testName" type="Element"/> |
| <var name="firstChild" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="retNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"sup"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testName"/> |
| <createTextNode var="textNode" obj="doc" data='""'/> |
| <appendChild var="retNode" obj="testName" newChild="textNode"/> |
| <createTextNode var="textNode" obj="doc" data='",000"'/> |
| <appendChild var="retNode" obj="testName" newChild="textNode"/> |
| <documentElement obj="doc" var="root"/> |
| <normalize obj="root"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"sup"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testName"/> |
| <firstChild interface="Node" obj="testName" var="firstChild"/> |
| <nodeValue obj="firstChild" var="childValue"/> |
| <assertEquals actual="childValue" expected='"56,000,000"' id="elementNormalizeAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementnormalize2.xml.notimpl |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementnormalize2"> |
| <metadata> |
| <title>hc_elementnormalize2</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add an empty text node to an existing attribute node, normalize the containing element |
| and check that the attribute node has eliminated the empty text. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-162CF083"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=482"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="root" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="firstChild" type="Node"/> |
| <var name="secondChild" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="emptyText" type="Text"/> |
| <var name="attrNode" type="Attr"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement obj="doc" var="root"/> |
| <createTextNode var="emptyText" obj="doc" data='""'/> |
| <getElementsByTagName interface="Element" obj="root" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="element"/> |
| <getAttributeNode var="attrNode" obj="element" name='"title"'/> |
| <appendChild var="retval" obj="attrNode" newChild="emptyText"/> |
| <normalize obj="element"/> |
| <getAttributeNode var="attrNode" obj="element" name='"title"'/> |
| <firstChild interface="Node" obj="attrNode" var="firstChild"/> |
| <nodeValue obj="firstChild" var="childValue"/> |
| <assertEquals actual="childValue" expected='"Yes"' id="firstChild" ignoreCase="false"/> |
| <nextSibling var="secondChild" obj="firstChild" interface="Node"/> |
| <assertNull actual="secondChild" id="secondChildNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementnotfounderr.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementnotfounderr"> |
| <metadata> |
| <title>hc_elementNotFoundErr</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeAttributeNode(oldAttr)" method raises a |
| NOT_FOUND_ERR DOMException if the "oldAttr" attribute |
| is not an attribute of the element. |
| Retrieve the last employee and attempt to remove |
| a non existing attribute node. This should cause the |
| intended exception to be raised. This test makes use |
| of the "createAttribute(name)" method from the Document |
| interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-D589198')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="oldAttribute" type="Attr"/> |
| <var name="addressElementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <var name="attrAddress" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="addressElementList"/> |
| <item interface="NodeList" obj="addressElementList" index="4" var="testAddress"/> |
| <createAttribute obj="doc" var="oldAttribute" name='"title"'/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeAttributeNode obj="testAddress" oldAttr="oldAttribute" var="attrAddress"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementremoveattribute.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementremoveattribute"> |
| <metadata> |
| <title>hc_elementRemoveAttribute</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeAttribute(name)" removes an attribute by name. |
| If the attribute has a default value, it is immediately |
| replaced. However, there is no default values in the HTML |
| compatible tests, so its value is "". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D6AC0F9"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="3" var="testEmployee"/> |
| <removeAttribute obj="testEmployee" name='"class"'/> |
| <getAttribute obj="testEmployee" var="attrValue" name='"class"'/> |
| <assertEquals actual="attrValue" expected='""' id="attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementremoveattributeaftercreate.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementremoveattributeaftercreate"> |
| <metadata> |
| <title>hc_elementRemoveAttributeAfterCreate</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeAttributeNode(oldAttr)" method removes the |
| specified attribute. |
| Retrieve the last child of the third employee, add a |
| new "lang" attribute to it and then try to remove it. |
| To verify that the node was removed use the |
| "getNamedItem(name)" method from the NamedNodeMap |
| interface. It also uses the "getAttributes()" method |
| from the Node interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--removeAttributeNode--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="districtAttr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <createAttribute obj="doc" var="newAttribute" name='"lang"'/> |
| <setAttributeNode obj="testEmployee" var="districtAttr" newAttr="newAttribute"/> |
| <removeAttributeNode obj="testEmployee" var="districtAttr" oldAttr="newAttribute"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItem obj="attributes" var="districtAttr" name='"lang"'/> |
| <assertNull actual="districtAttr" id="removed_item_null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementremoveattributenode.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementremoveattributenode"> |
| <metadata> |
| <title>hc_elementRemoveAttributeNode</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeAttributeNode(oldAttr)" method returns the |
| node that was removed. |
| Retrieve the last child of the third employee and |
| remove its "class" Attr node. The method should |
| return the old attribute node. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D589198"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="removedAttr" type="Attr"/> |
| <var name="removedValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <getAttributeNode obj="testEmployee" var="streetAttr" name='"class"'/> |
| <removeAttributeNode obj="testEmployee" var="removedAttr" oldAttr="streetAttr"/> |
| <assertNotNull actual="removedAttr" id="removedAttrNotNull"/> |
| <value interface="Attr" obj="removedAttr" var="removedValue"/> |
| <assertEquals actual="removedValue" expected='"No"' id="elementRemoveAttributeNodeAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementreplaceattributewithself.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementreplaceattributewithself"> |
| <metadata> |
| <title>hc_elementReplaceAttributeWithSelf</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| This test calls setAttributeNode to replace an attribute with itself. |
| Since the node is not an attribute of another Element, it would |
| be inappropriate to throw an INUSE_ATTRIBUTE_ERR. |
| This test was derived from elementinuserattributeerr which |
| inadvertanly made this test. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-06-09</date> |
| <!--setAttributeNode--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="replacedAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <getAttributeNode var="streetAttr" obj="testEmployee" name='"class"'/> |
| <setAttributeNode obj="testEmployee" var="replacedAttr" newAttr="streetAttr"/> |
| <assertSame actual="replacedAttr" expected="streetAttr" id="replacedAttr"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementreplaceexistingattribute.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementreplaceexistingattribute"> |
| <metadata> |
| <title>hc_elementReplaceExistingAttribute</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method adds a new |
| attribute to the Element. If the "newAttr" Attr node is |
| already present in this element, it should replace the |
| existing one. |
| Retrieve the last child of the third employee and add a |
| new attribute node by invoking the "setAttributeNode(new |
| Attr)" method. The new attribute node to be added is |
| "class", which is already present in this element. The |
| method should replace the existing Attr node with the |
| new one. This test uses the "createAttribute(name)" |
| method from the Document interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="strong" type="DOMString"/> |
| <var name="setAttr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <createAttribute obj="doc" var="newAttribute" name='"class"'/> |
| <setAttributeNode var="setAttr" obj="testEmployee" newAttr="newAttribute"/> |
| <getAttribute obj="testEmployee" var="strong" name='"class"'/> |
| <assertEquals actual="strong" expected='""' id="replacedValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementreplaceexistingattributegevalue.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementreplaceexistingattributegevalue"> |
| <metadata> |
| <title>hc_elementReplaceExistingAttributeGeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the "setAttributeNode(newAttr)" method replaces an |
| existing Attr node with the same name, then it should |
| return the previously existing Attr node. |
| Retrieve the last child of the third employee and add a |
| new attribute node. The new attribute node is "class", |
| which is already present in this Element. The method |
| should return the existing Attr node(old "class" Attr). |
| This test uses the "createAttribute(name)" method |
| from the Document interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--setAttributeNode--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <createAttribute obj="doc" var="newAttribute" name='"class"'/> |
| <setAttributeNode obj="testEmployee" var="streetAttr" newAttr="newAttribute"/> |
| <assertNotNull actual="streetAttr" id="previousAttrNotNull"/> |
| <value interface="Attr" obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected='"No"' id="previousAttrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementretrieveallattributes.xml.kfail |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementretrieveallattributes"> |
| <metadata> |
| <title>hc_elementretrieveallattributes</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a list of all the attributes of the last child |
| of the first "p" element by using the "getAttributes()" |
| method. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=184"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="attribute" type="Attr"/> |
| <var name="attributeName" type="DOMString"/> |
| <var name="actual" type="Collection"/> |
| <var name="htmlExpected" type="Collection"> |
| <member>"title"</member> |
| </var> |
| <var name="expected" type="Collection"> |
| <member>"title"</member> |
| <member>"dir"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="addressList"/> |
| <item interface="NodeList" obj="addressList" index="0" var="testAddress"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <for-each collection="attributes" member="attribute"> |
| <nodeName var="attributeName" obj="attribute"/> |
| <append collection="actual" item="attributeName"/> |
| </for-each> |
| <if><contentType type="text/html"/> |
| <assertEquals id="htmlAttributeNames" actual="actual" expected="htmlExpected" ignoreCase="true"/> |
| <else> |
| <assertEquals id="attributeNames" actual="actual" expected="expected" ignoreCase="true"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementretrieveattrvalue.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementretrieveattrvalue"> |
| <metadata> |
| <title>hc_elementRetrieveAttrValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getAttribute(name)" method returns an attribute |
| value by name. |
| Retrieve the second address element, then |
| invoke the 'getAttribute("class")' method. This should |
| return the value of the attribute("No"). |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--getAttribute--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-666EE0F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testAddress"/> |
| <getAttribute obj="testAddress" var="attrValue" name='"class"'/> |
| <assertEquals actual="attrValue" expected='"No"' id="attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementretrievetagname.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementretrievetagname"> |
| <metadata> |
| <title>hc_elementRetrieveTagName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagName()" method returns a NodeList |
| of all descendant elements with a given tagName. |
| Invoke the "getElementsByTagName()" method and create |
| a NodeList of "code" elements. Retrieve the second |
| "code" element in the list and return the NodeName. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--nodeName attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <!--tagName attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-104682815"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="strong" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"code"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="testEmployee"/> |
| <nodeName obj="testEmployee" var="strong"/> |
| <assertEquals actual="strong" expected='"code"' id="nodename" ignoreCase="auto"/> |
| <tagName obj="testEmployee" var="strong"/> |
| <assertEquals actual="strong" expected='"code"' id="tagname" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementsetattributenodenull.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementsetattributenodenull"> |
| <metadata> |
| <title>hc_elementSetAttributeNodeNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method returns the |
| null value if no previously existing Attr node with the |
| same name was replaced. |
| Retrieve the last child of the third employee and add a |
| new attribute to it. The new attribute node added is |
| "lang", which is not part of this Element. The |
| method should return the null value. |
| This test uses the "createAttribute(name)" |
| method from the Document interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="districtAttr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testEmployee"/> |
| <createAttribute obj="doc" var="newAttribute" name='"lang"'/> |
| <setAttributeNode obj="testEmployee" var="districtAttr" newAttr="newAttribute"/> |
| <assertNull actual="districtAttr" id="elementSetAttributeNodeNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_elementwrongdocumenterr.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_elementwrongdocumenterr"> |
| <metadata> |
| <title>hc_elementWrongDocumentErr</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method raises an |
| "WRONG_DOCUMENT_ERR DOMException if the "newAttr" |
| was created from a different document than the one that |
| created this document. |
| Retrieve the last employee and attempt to set a new |
| attribute node for its "employee" element. The new |
| attribute was created from a document other than the |
| one that created this element, therefore a |
| WRONG_DOCUMENT_ERR DOMException should be raised. |
| This test uses the "createAttribute(newAttr)" method |
| from the Document interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-887236154"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-887236154')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="addressElementList" type="NodeList"/> |
| <var name="testAddress" type="Element"/> |
| <var name="attrAddress" type="Attr"/> |
| <load var="doc1" href="hc_staff" willBeModified="true"/> |
| <load var="doc2" href="hc_staff" willBeModified="false"/> |
| <createAttribute obj="doc2" var="newAttribute" name='"newAttribute"'/> |
| <getElementsByTagName interface="Document" obj="doc1" tagname='"acronym"' var="addressElementList"/> |
| <item interface="NodeList" obj="addressElementList" index="4" var="testAddress"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <setAttributeNode obj="testAddress" newAttr="newAttribute" var="attrAddress"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_entitiesremovenameditem1.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_entitiesremovenameditem1"> |
| <metadata> |
| <title>hc_entitiesremovenameditem1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An attempt to add remove an entity should result in a NO_MODIFICATION_ERR. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <!-- DocumentType.entities --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1788794630"/> |
| <!-- NamedNodeMap.removeNamedItem --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D58B193"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities var="entities" obj="docType"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeNamedItem var="retval" obj="entities" name='"alpha"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_entitiessetnameditem1.xml.notimpl |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_entitiessetnameditem1"> |
| <metadata> |
| <title>hc_entitiessetnameditem1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An attempt to add an element to the named node map returned by entities should |
| result in a NO_MODIFICATION_ERR or HIERARCHY_REQUEST_ERR. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <!-- DocumentType.entities --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1788794630"/> |
| <!-- NamedNodeMap.setNamedItem --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="retval" type="Node"/> |
| <var name="elem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities var="entities" obj="docType"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <createElement var="elem" obj="doc" tagName='"br"'/> |
| <try> |
| <setNamedItem var="retval" obj="entities" arg="elem"/> |
| <fail id="throw_HIER_OR_NO_MOD_ERR"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| </catch> |
| </try> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapchildnoderange.xml.kfail |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapchildnoderange"> |
| <metadata> |
| <title>hc_namednodemapchildnoderange</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a NamedNodeMap object from the attributes of the |
| last child of the third "p" element and traverse the |
| list from index 0 thru length -1. All indices should |
| be valid. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!--item--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| <!--length attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D0FB19E"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=250"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="child" type="Node"/> |
| <var name="strong" type="DOMString"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="2"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <length var="length" obj="attributes" interface="NamedNodeMap"/> |
| <if><contentType type="text/html"/> |
| <assertEquals actual="length" expected="2" id="htmlLength" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="length" expected="3" id="length" ignoreCase="false"/> |
| <item var="child" index="2" obj="attributes" interface="NamedNodeMap"/> |
| <assertNotNull actual="child" id="attr2"/> |
| </else> |
| </if> |
| <item var="child" index="0" obj="attributes" interface="NamedNodeMap"/> |
| <assertNotNull actual="child" id="attr0"/> |
| <item var="child" index="1" obj="attributes" interface="NamedNodeMap"/> |
| <assertNotNull actual="child" id="attr1"/> |
| <item var="child" index="3" obj="attributes" interface="NamedNodeMap"/> |
| <assertNull actual="child" id="attr3"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapgetnameditem.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapgetnameditem"> |
| <metadata> |
| <title>hc_namednodemapgetnameditem</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the second "p" element and create a NamedNodeMap |
| listing of the attributes of the last child. Once the |
| list is created an invocation of the "getNamedItem(name)" |
| method is done with name="title". This should result |
| in the title Attr node being returned. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1074577549"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Jun/0011.html"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="1"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name='"title"'/> |
| <nodeName obj="domesticAttr" var="attrName"/> |
| <assertEquals actual="attrName" expected='"title"' |
| id="nodeName" ignoreCase="auto" context="attribute"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapinuseattributeerr.xml.kfail |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapinuseattributeerr"> |
| <metadata> |
| <title>hc_namedNodeMapInUseAttributeErr</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setNamedItem(arg)" method raises a |
| INUSE_ATTRIBUTE_ERR DOMException if "arg" is an |
| Attr that is already in an attribute of another Element. |
| Create a NamedNodeMap object from the attributes of the |
| last child of the third employee and attempt to add |
| an attribute that is already being used by the first |
| employee. This should raise the desired exception. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1025163788')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="firstNode" type="Element"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="setAttr" type="Attr"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="firstNode" index="0"/> |
| <createAttribute obj="doc" var="domesticAttr" name='"title"'/> |
| <value interface="Attr" obj="domesticAttr" value='"Yα"'/> |
| <setAttributeNode var="setAttr" obj="firstNode" newAttr="domesticAttr"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="2"/> |
| <attributes obj="testNode" var="attributes"/> |
| <assertDOMException id="throw_INUSE_ATTRIBUTE_ERR"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setNamedItem var="setNode" interface="NamedNodeMap" obj="attributes" arg="domesticAttr"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapnotfounderr.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapnotfounderr"> |
| <metadata> |
| <title>hc_namednodemapNotFoundErr</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeNamedItem(name)" method raises a |
| NOT_FOUND_ERR DOMException if there is not a node |
| named "strong" in the map. |
| Create a NamedNodeMap object from the attributes of the |
| last child of the third employee and attempt to remove |
| the "lang" attribute. There is not a node named |
| "lang" in the list and therefore the desired |
| exception should be raised. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D58B193"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-D58B193')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="2"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeNamedItem var="removedNode" interface="NamedNodeMap" obj="attributes" name='"lang"'/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapnumberofnodes.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapnumberofnodes"> |
| <metadata> |
| <title>hc_namednodemapnumberofnodes</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the second "p" element and evaluate Node.attributes.length. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!--length attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D0FB19E"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=250"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="2"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <length var="length" obj="attributes" interface="NamedNodeMap"/> |
| <if><contentType type="text/html"/> |
| <assertEquals actual="length" expected="2" id="htmlLength" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="length" expected="3" id="length" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapremovenameditem.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapremovenameditem"> |
| <metadata> |
| <title>hc_namednodemapRemoveNamedItem</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeNamedItem(name)" method removes a node |
| specified by name. |
| Retrieve the third employee and create a NamedNodeMap |
| object of the attributes of the last child. Once the |
| list is created invoke the "removeNamedItem(name)" |
| method with name="class". This should result |
| in the removal of the specified attribute. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D58B193"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="specified" type="boolean"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <removeNamedItem var="removedNode" interface="NamedNodeMap" obj="attributes" name='"class"'/> |
| <getNamedItem obj="attributes" var="streetAttr" name='"class"'/> |
| <assertNull actual="streetAttr" id="isnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapreturnattrnode.xml.kfail |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapreturnattrnode"> |
| <metadata> |
| <title>hc_namednodemapreturnattrnode</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the second p element and create a NamedNodeMap |
| listing of the attributes of the last child. Once the |
| list is created an invocation of the "getNamedItem(name)" |
| method is done with name="class". This should result |
| in the method returning an Attr node. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--getNamedItem--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1074577549"/> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!--name attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1112119403"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Node"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="1"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name='"class"'/> |
| <assertInstanceOf obj="streetAttr" type="Attr" id="typeAssert"/> |
| <nodeName obj="streetAttr" var="attrName"/> |
| <assertEquals actual="attrName" expected='"class"' id="nodeName" ignoreCase="auto" context="attribute"/> |
| <name obj="streetAttr" var="attrName" interface="Attr"/> |
| <assertEquals actual="attrName" expected='"class"' id="name" ignoreCase="auto" context="attribute"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapreturnfirstitem.xml.kfail |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapreturnfirstitem"> |
| <metadata> |
| <title>hc_namednodemapReturnFirstItem</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "item(index)" method returns the indexth item in |
| the map(test for first item). |
| Retrieve the second "acronym" get the NamedNodeMap of the attributes. Since the |
| DOM does not specify an order of these nodes the contents |
| of the FIRST node can contain either "title", "class" or "dir". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Jun/0011.html"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=184"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="child" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="htmlExpected" type="Collection"> |
| <member>"title"</member> |
| <member>"class"</member> |
| </var> |
| <var name="expected" type="Collection"> |
| <member>"title"</member> |
| <member>"class"</member> |
| <member>"dir"</member> |
| </var> |
| <var name="actual" type="Collection"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="1"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <for-each collection="attributes" member="child"> |
| <nodeName obj="child" var="nodeName"/> |
| <append collection="actual" item="nodeName"/> |
| </for-each> |
| <if><contentType type="text/html"/> |
| <assertEquals id="attrName_html" actual="actual" expected="htmlExpected" ignoreCase="true"/> |
| <else> |
| <assertEquals id="attrName" actual="actual" expected="expected" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapreturnlastitem.xml.kfail |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapreturnlastitem"> |
| <metadata> |
| <title>hc_namednodemapReturnLastItem</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "item(index)" method returns the indexth item in |
| the map(test for last item). |
| Retrieve the second "acronym" and get the attribute name. Since the |
| DOM does not specify an order of these nodes the contents |
| of the LAST node can contain either "title" or "class". |
| The test should return "true" if the LAST node is either |
| of these values. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Jun/0011.html"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=184"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="child" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="htmlExpected" type="Collection"> |
| <member>"title"</member> |
| <member>"class"</member> |
| </var> |
| <var name="expected" type="Collection"> |
| <member>"title"</member> |
| <member>"class"</member> |
| <member>"dir"</member> |
| </var> |
| <var name="actual" type="Collection"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="1"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <for-each collection="attributes" member="child"> |
| <nodeName obj="child" var="nodeName"/> |
| <append collection="actual" item="nodeName"/> |
| </for-each> |
| <if><contentType type="text/html"/> |
| <assertEquals id="attrName_html" actual="actual" expected="htmlExpected" ignoreCase="true"/> |
| <else> |
| <assertEquals id="attrName" actual="actual" expected="expected" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapreturnnull.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapreturnnull"> |
| <metadata> |
| <title>hc_namednodemapReturnNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getNamedItem(name)" method returns null of the |
| specified name did not identify any node in the map. |
| Retrieve the second employee and create a NamedNodeMap |
| listing of the attributes of the last child. Once the |
| list is created an invocation of the "getNamedItem(name)" |
| method is done with name="lang". This name does not |
| match any names in the list therefore the method should |
| return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--getNamedItem--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1074577549"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="districtNode" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="1"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItem obj="attributes" var="districtNode" name='"lang"'/> |
| <assertNull actual="districtNode" id="langAttrNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapsetnameditem.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapsetnameditem"> |
| <metadata> |
| <title>hc_namednodemapsetnameditem</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the second "p" element and create a NamedNodeMap |
| object from the attributes of the last child by |
| invoking the "getAttributes()" method. Once the |
| list is created an invocation of the "setNamedItem(arg)" |
| method is done with arg=newAttr, where newAttr is a |
| new Attr Node previously created. The "setNamedItem(arg)" |
| method should add then new node to the NamedNodeItem |
| object by using its "nodeName" attribute("lang'). |
| This node is then retrieved using the "getNamedItem(name)" |
| method. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Jun/0011.html"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="districtNode" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="1"/> |
| <createAttribute obj="doc" var="newAttribute" name='"lang"'/> |
| <attributes obj="testAddress" var="attributes"/> |
| <setNamedItem var="setNode" obj="attributes" arg="newAttribute"/> |
| <getNamedItem obj="attributes" var="districtNode" name='"lang"'/> |
| <nodeName obj="districtNode" var="attrName"/> |
| <assertEquals actual="attrName" expected='"lang"' id="nodeName" |
| ignoreCase="auto" context="attribute"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapsetnameditemreturnvalue.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapsetnameditemreturnvalue"> |
| <metadata> |
| <title>hc_namednodemapSetNamedItemReturnValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the "setNamedItem(arg)" method replaces an already |
| existing node with the same name then the already |
| existing node is returned. |
| Retrieve the third employee and create a NamedNodeMap |
| object from the attributes of the last child by |
| invoking the "getAttributes()" method. Once the |
| list is created an invocation of the "setNamedItem(arg)" |
| method is done with arg=newAttr, where newAttr is a |
| new Attr Node previously created and whose node name |
| already exists in the map. The "setNamedItem(arg)" |
| method should replace the already existing node with |
| the new one and return the existing node. |
| This test uses the "createAttribute(name)" method from |
| the document interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="newNode" type="Node"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <createAttribute obj="doc" var="newAttribute" name='"class"'/> |
| <attributes obj="testAddress" var="attributes"/> |
| <setNamedItem interface="NamedNodeMap" obj="attributes" var="newNode" arg="newAttribute"/> |
| <assertNotNull actual="newNode" id="previousAttrNotNull"/> |
| <nodeValue obj="newNode" var="attrValue"/> |
| <assertEquals actual="attrValue" expected='"No"' id="previousAttrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapsetnameditemthatexists.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapsetnameditemthatexists"> |
| <metadata> |
| <title>hc_namednodemapSetNamedItemThatExists</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the node to be added by the "setNamedItem(arg)" method |
| already exists in the NamedNodeMap, it is replaced by |
| the new one. |
| Retrieve the second employee and create a NamedNodeMap |
| object from the attributes of the last child by |
| invoking the "getAttributes()" method. Once the |
| list is created an invocation of the "setNamedItem(arg)" |
| method is done with arg=newAttr, where newAttr is a |
| new Attr Node previously created and whose node name |
| already exists in the map. The "setNamedItem(arg)" |
| method should replace the already existing node with |
| the new one. |
| This node is then retrieved using the "getNamedItem(name)" |
| method. This test uses the "createAttribute(name)" |
| method from the document interface |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="districtNode" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="1"/> |
| <createAttribute obj="doc" var="newAttribute" name='"class"'/> |
| <attributes obj="testAddress" var="attributes"/> |
| <setNamedItem var="setNode" obj="attributes" arg="newAttribute"/> |
| <getNamedItem obj="attributes" var="districtNode" name='"class"'/> |
| <nodeValue obj="districtNode" var="attrValue"/> |
| <assertEquals actual="attrValue" expected='""' id="namednodemapSetNamedItemThatExistsAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapsetnameditemwithnewvalue.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapsetnameditemwithnewvalue"> |
| <metadata> |
| <title>hc_namednodemapSetNamedItemWithNewValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the "setNamedItem(arg)" method does not replace an |
| existing node with the same name then it returns null. |
| Retrieve the third employee and create a NamedNodeMap |
| object from the attributes of the last child. |
| Once the list is created the "setNamedItem(arg)" method |
| is invoked with arg=newAttr, where newAttr is a |
| newly created Attr Node and whose node name |
| already exists in the map. The "setNamedItem(arg)" |
| method should add the new node and return null. |
| This test uses the "createAttribute(name)" method from |
| the document interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=243"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="newNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <createAttribute obj="doc" var="newAttribute" name='"lang"'/> |
| <attributes obj="testAddress" var="attributes"/> |
| <setNamedItem interface="NamedNodeMap" obj="attributes" var="newNode" arg="newAttribute"/> |
| <assertNull actual="newNode" id="prevValueNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_namednodemapwrongdocumenterr.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_namednodemapwrongdocumenterr"> |
| <metadata> |
| <title>hc_namednodemapWrongDocumentErr</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setNamedItem(arg)" method raises a |
| WRONG_DOCUMENT_ERR DOMException if "arg" was created |
| from a different document than the one that created |
| the NamedNodeMap. |
| Create a NamedNodeMap object from the attributes of the |
| last child of the third employee and attempt to add |
| another Attr node to it that was created from a |
| different DOM document. This should raise the desired |
| exception. This method uses the "createAttribute(name)" |
| method from the Document interface. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1025163788')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="newAttribute" type="Node"/> |
| <var name="strong" type="DOMString"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc1" href="hc_staff" willBeModified="true"/> |
| <load var="doc2" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc1" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <createAttribute obj="doc2" var="newAttribute" name='"newAttribute"'/> |
| <attributes obj="testAddress" var="attributes"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <setNamedItem var="setNode" obj="attributes" arg="newAttribute"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeappendchild.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeappendchild"> |
| <metadata> |
| <title>hc_nodeAppendChild</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the second "p" and append a "br" Element |
| node to the list of children. The last node in the list |
| is then retrieved and its NodeName examined. The |
| "getNodeName()" method should return "br". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="createdNode" type="Node"/> |
| <var name="lchild" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <createElement obj="doc" tagName='"br"' var="createdNode"/> |
| <appendChild var="appendedChild" obj="employeeNode" newChild="createdNode"/> |
| <lastChild interface="Node" obj="employeeNode" var="lchild"/> |
| <nodeName obj="lchild" var="childName"/> |
| <assertEquals actual="childName" expected='"br"' id="nodeName" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeappendchildchildexists.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeappendchildchildexists"> |
| <metadata> |
| <title>hc_nodeAppendChildChildExists</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the "newChild" is already in the tree, it is first |
| removed before the new one is appended. |
| Retrieve the "em" second employee and |
| append the first child to the end of the list. After |
| the "appendChild(newChild)" method is invoked the first |
| child should be the one that was second and the last |
| child should be the one that was first. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="childList" type="NodeList"/> |
| <var name="childNode" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="memberNode" type="Node"/> |
| <var name="memberName" type="DOMString"/> |
| <var name="refreshedActual" type="List"/> |
| <var name="actual" type="List"/> |
| <var name="nodeType" type="int"/> |
| <var name="expected" type="List"> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"em"</member> |
| </var> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="childNode"/> |
| <getElementsByTagName interface="Element" obj="childNode" var="childList" tagname='"*"'/> |
| <item interface="NodeList" obj="childList" index="0" var="newChild"/> |
| <appendChild var="appendedChild" obj="childNode" newChild="newChild"/> |
| <for-each collection="childList" member="memberNode"> |
| <nodeName var="memberName" obj="memberNode"/> |
| <append collection="actual" item="memberName"/> |
| </for-each> |
| <assertEquals id="liveByTagName" actual="actual" expected='expected' ignoreCase="auto"/> |
| <childNodes var="childList" obj="childNode"/> |
| <for-each collection="childList" member="memberNode"> |
| <nodeType var="nodeType" obj="memberNode"/> |
| <if><equals actual="nodeType" expected="1"/> |
| <nodeName var="memberName" obj="memberNode"/> |
| <append collection="refreshedActual" item="memberName"/> |
| </if> |
| </for-each> |
| <assertEquals id="refreshedChildNodes" actual="refreshedActual" expected='expected' ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeappendchilddocfragment.xml |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeappendchilddocfragment"> |
| <metadata> |
| <title>hc_nodeAppendChildDocFragment</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the "newChild" is a DocumentFragment object then |
| all its content is added to the child list of this node. |
| Create and populate a new DocumentFragment object and |
| append it to the second employee. After the |
| "appendChild(newChild)" method is invoked retrieve the |
| new nodes at the end of the list, they should be the |
| two Element nodes from the DocumentFragment. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="newdocFragment" type="DocumentFragment"/> |
| <var name="newChild1" type="Node"/> |
| <var name="newChild2" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="expected" type="List"> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"br"</member> |
| <member>"b"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <createDocumentFragment obj="doc" var="newdocFragment"/> |
| <createElement obj="doc" tagName='"br"' var="newChild1"/> |
| <createElement obj="doc" tagName='"b"' var="newChild2"/> |
| <appendChild var="appendedChild" obj="newdocFragment" newChild="newChild1"/> |
| <appendChild var="appendedChild" obj="newdocFragment" newChild="newChild2"/> |
| <appendChild var="appendedChild" obj="employeeNode" newChild="newdocFragment"/> |
| <for-each collection="childList" member="child"> |
| <nodeType var="nodeType" obj="child"/> |
| <if><equals actual="nodeType" expected="1"/> |
| <nodeName var="childName" obj="child"/> |
| <append collection="result" item="childName"/> |
| </if> |
| </for-each> |
| <assertEquals actual="result" expected="expected" ignoreCase="auto" id="nodeNames"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeappendchildgetnodename.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeappendchildgetnodename"> |
| <metadata> |
| <title>hc_nodeAppendChildGetNodeName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "appendChild(newChild)" method returns the node |
| added. |
| Append a newly created node to the child list of the |
| second employee and check the NodeName returned. The |
| "getNodeName()" method should return "br". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="newChild" type="Node"/> |
| <var name="appendNode" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <createElement obj="doc" tagName='"br"' var="newChild"/> |
| <appendChild obj="employeeNode" newChild="newChild" var="appendNode"/> |
| <nodeName obj="appendNode" var="childName"/> |
| <assertEquals actual="childName" expected='"br"' id="nodeName" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeappendchildinvalidnodetype.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeappendchildinvalidnodetype"> |
| <metadata> |
| <title>hc_nodeAppendChildInvalidNodeType</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "appendChild(newChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if this node is of |
| a type that does not allow children of the type "newChild" |
| to be inserted. |
| Retrieve the root node and attempt to append a newly |
| created Attr node. An Element node cannot have children |
| of the "Attr" type, therefore the desired exception |
| should be raised. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-184E7107')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Element"/> |
| <var name="newChild" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <createAttribute obj="doc" name='"newAttribute"' var="newChild"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <appendChild var="appendedChild" obj="rootNode" newChild="newChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeappendchildnewchilddiffdocument.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeappendchildnewchilddiffdocument"> |
| <metadata> |
| <title>hc_nodeAppendChildNewChildDiffDocument</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "appendChild(newChild)" method raises a |
| WRONG_DOCUMENT_ERR DOMException if the "newChild" was |
| created from a different document than the one that |
| created this node. |
| Retrieve the second employee and attempt to append |
| a node created from a different document. An attempt |
| to make such a replacement should raise the desired |
| exception. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-184E7107')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <load var="doc2" href="hc_staff" willBeModified="true"/> |
| <createElement obj="doc1" tagName='"br"' var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc2" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <appendChild var="appendedChild" obj="elementNode" newChild="newChild"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeappendchildnodeancestor.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeappendchildnodeancestor"> |
| <metadata> |
| <title>hc_nodeAppendChildNodeAncestor</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "appendChild(newChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if the node to |
| append is one of this node's ancestors. |
| Retrieve the second employee and attempt to append |
| an ancestor node(root node) to it. |
| An attempt to make such an addition should raise the |
| desired exception. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-184E7107')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement obj="doc" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <appendChild var="appendedChild" obj="employeeNode" newChild="newChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeattributenodeattribute.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeattributenodeattribute"> |
| <metadata> |
| <title>hc_characterdataDeleteDataEnd</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getAttributes()" method invoked on an Attribute |
| Node returns null. |
| Retrieve the first attribute from the last child of the |
| first employee and invoke the "getAttributes()" method |
| on the Attribute Node. It should return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="NamedNodeMap"/> |
| <var name="attrNode" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <attributes obj="testAddr" var="addrAttr"/> |
| <item interface="NamedNodeMap" obj="addrAttr" var="attrNode" index="0"/> |
| <attributes obj="attrNode" var="attrList"/> |
| <assertNull actual="attrList" id="nodeAttributeNodeAttributeAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeattributenodename.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeattributenodename"> |
| <metadata> |
| <title>hc_nodeattributenodename</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the Attribute named "title" from the last |
| child of the first p element and check the string returned |
| by the "getNodeName()" method. It should be equal to |
| "title". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <getAttributeNode obj="testAddr" name='"title"' var="addrAttr"/> |
| <nodeName obj="addrAttr" var="attrName"/> |
| <assertEquals actual="attrName" expected='"title"' id="nodeName" |
| ignoreCase="auto" context="attribute"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeattributenodetype.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeattributenodetype"> |
| <metadata> |
| <title>hc_nodeAttributeNodeType</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getNodeType()" method for an Attribute Node |
| returns the constant value 2. |
| Retrieve the first attribute from the last child of |
| the first employee and invoke the "getNodeType()" |
| method. The method should return 2. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <getAttributeNode obj="testAddr" name='"title"' var="addrAttr"/> |
| <nodeType obj="addrAttr" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="2" id="nodeAttrNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeattributenodevalue.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeattributenodevalue"> |
| <metadata> |
| <title>hc_nodeAttributeNodeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for an |
| Attribute Node is the value of the Attribute. |
| Retrieve the Attribute named "title" from the last |
| child of the first "p" and check the string returned |
| by the "getNodeValue()" method. It should be equal to |
| "Yes". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <getAttributeNode obj="testAddr" name='"title"' var="addrAttr"/> |
| <nodeValue obj="addrAttr" var="attrValue"/> |
| <assertEquals actual="attrValue" expected='"Yes"' id="nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodechildnodes.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodechildnodes"> |
| <metadata> |
| <title>hc_nodeChildNodes</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getChildNodes()" method returns a NodeList |
| that contains all children of this node. |
| Retrieve the second employee and check the NodeList |
| returned by the "getChildNodes()" method. The |
| length of the list should be 13. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childNode" type="Node"/> |
| <var name="childNodes" type="NodeList"/> |
| <var name="nodeType" type="int"/> |
| <var name="childName" type="DOMString"/> |
| <var name="actual" type="List"/> |
| <var name="expected" type="List"> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childNodes"/> |
| <for-each collection="childNodes" member="childNode"> |
| <nodeType var="nodeType" obj="childNode"/> |
| <nodeName var="childName" obj="childNode"/> |
| <if><equals actual="nodeType" expected="1"/> |
| <append collection="actual" item="childName"/> |
| <else> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="textNodeType"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="actual" expected="expected" id="elementNames" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodechildnodesappendchild.xml |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodechildnodesappendchild"> |
| <metadata> |
| <title>hc_nodeChildNodesAppendChild</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The NodeList returned by the "getChildNodes()" method |
| is live. Changes on the node's children are immediately |
| reflected on the nodes returned in the NodeList. |
| Create a NodeList of the children of the second employee |
| and then add a newly created element that was created |
| by the "createElement()" method(Document Interface) to |
| the second employee by using the "appendChild()" method. |
| The length of the NodeList should reflect this new |
| addition to the child list. It should return the value 14. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="createdNode" type="Node"/> |
| <var name="childNode" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="childType" type="int"/> |
| <var name="textNode" type="Node"/> |
| <var name="actual" type="List"/> |
| <var name="expected" type="List"> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| <member>"br"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <createElement obj="doc" var="createdNode" tagName='"br"'/> |
| <appendChild obj="employeeNode" newChild="createdNode" var="employeeNode"/> |
| <for-each collection="childList" member="childNode"> |
| <nodeName var="childName" obj="childNode"/> |
| <nodeType var="childType" obj="childNode"/> |
| <if><equals actual="childType" expected="1"/> |
| <append collection="actual" item="childName"/> |
| <else> |
| <assertEquals id="textNodeType" actual="childType" expected="3" ignoreCase="false"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="actual" expected="expected" id="childElements" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodechildnodesempty.xml.int-broken |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodechildnodesempty"> |
| <metadata> |
| <title>hc_nodeChildNodesEmpty</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getChildNodes()" method returns a NodeList |
| that contains all children of this node. If there |
| are not any children, this is a NodeList that does not |
| contain any nodes. |
| Retrieve the character data of the second "em" node and |
| invoke the "getChildNodes()" method. The |
| NodeList returned should not have any nodes. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="childList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"em"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <firstChild var="textNode" obj="employeeNode"/> |
| <childNodes var="childList" obj="textNode"/> |
| <length var="length" obj="childList" interface="NodeList"/> |
| <assertEquals expected="0" actual="length" id="length_zero" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodecloneattributescopied.xml.kfail |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodecloneattributescopied"> |
| <metadata> |
| <title>hc_nodecloneattributescopied</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the second acronym element and invoke |
| the cloneNode method. The |
| duplicate node returned by the method should copy the |
| attributes associated with this node. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=184"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="addressNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="attributeNode" type="Node"/> |
| <var name="attributeName" type="DOMString"/> |
| <var name="result" type="Collection"/> |
| <var name="htmlExpected" type="Collection"> |
| <member>"class"</member> |
| <member>"title"</member> |
| </var> |
| <var name="expected" type="Collection"> |
| <member>"class"</member> |
| <member>"title"</member> |
| <member>"dir"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="addressNode"/> |
| <cloneNode obj="addressNode" deep="false" var="clonedNode"/> |
| <attributes obj="clonedNode" var="attributes"/> |
| <for-each collection="attributes" member="attributeNode"> |
| <nodeName obj="attributeNode" var="attributeName"/> |
| <append collection="result" item="attributeName"/> |
| </for-each> |
| <if><contentType type="text/html"/> |
| <assertEquals actual="result" expected="htmlExpected" id="nodeNames_html" ignoreCase="true"/> |
| <else> |
| <assertEquals actual="result" expected="expected" id="nodeNames" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeclonefalsenocopytext.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeclonefalsenocopytext"> |
| <metadata> |
| <title>hc_nodeCloneFalseNoCopyText</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "cloneNode(deep)" method does not copy text unless it |
| is deep cloned.(Test for deep=false) |
| Retrieve the fourth child of the second employee and |
| the "cloneNode(deep)" method with deep=false. The |
| duplicate node returned by the method should not copy |
| any text data contained in this node. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="childNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="lastChildNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="3" var="childNode"/> |
| <cloneNode obj="childNode" deep="false" var="clonedNode"/> |
| <lastChild interface="Node" obj="clonedNode" var="lastChildNode"/> |
| <assertNull actual="lastChildNode" id="nodeCloneFalseNoCopyTextAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeclonegetparentnull.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeclonegetparentnull"> |
| <metadata> |
| <title>hc_nodeCloneGetParentNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The duplicate node returned by the "cloneNode(deep)" |
| method does not have a ParentNode. |
| Retrieve the second employee and invoke the |
| "cloneNode(deep)" method with deep=false. The |
| duplicate node returned should return null when the |
| "getParentNode()" is invoked. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="parentNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <cloneNode obj="employeeNode" deep="false" var="clonedNode"/> |
| <parentNode interface="Node" obj="clonedNode" var="parentNode"/> |
| <assertNull actual="parentNode" id="nodeCloneGetParentNullAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeclonenodefalse.xml.int-broken |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeclonenodefalse"> |
| <metadata> |
| <title>hc_nodeCloneNodeFalse</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "cloneNode(deep)" method returns a copy of the node |
| only if deep=false. |
| Retrieve the second employee and invoke the |
| "cloneNode(deep)" method with deep=false. The |
| method should only clone this node. The NodeName and |
| length of the NodeList are checked. The "getNodeName()" |
| method should return "employee" and the "getLength()" |
| method should return 0. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="cloneName" type="DOMString"/> |
| <var name="cloneChildren" type="NodeList"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <cloneNode obj="employeeNode" deep="false" var="clonedNode"/> |
| <nodeName obj="clonedNode" var="cloneName"/> |
| <assertEquals actual="cloneName" expected='"p"' ignoreCase="auto" id="strong"/> |
| <childNodes obj="clonedNode" var="cloneChildren"/> |
| <length interface="NodeList" obj="cloneChildren" var="length"/> |
| <assertEquals actual="length" expected="0" ignoreCase="false" id="length"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeclonenodetrue.xml.kfail |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeclonenodetrue"> |
| <metadata> |
| <title>hc_nodeCloneNodeTrue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "cloneNode(deep)" method returns a copy of the node |
| and the subtree under it if deep=true. |
| Retrieve the second employee and invoke the |
| "cloneNode(deep)" method with deep=true. The |
| method should clone this node and the subtree under it. |
| The NodeName of each child in the returned node is |
| checked to insure the entire subtree under the second |
| employee was cloned. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="clonedList" type="NodeList"/> |
| <var name="clonedChild" type="Node"/> |
| <var name="clonedChildName" type="DOMString"/> |
| <var name="origList" type="NodeList"/> |
| <var name="origChild" type="Node"/> |
| <var name="origChildName" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="expected" type="List"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="origList"/> |
| <for-each collection="origList" member="origChild"> |
| <nodeName obj="origChild" var="origChildName"/> |
| <append collection="expected" item="origChildName"/> |
| </for-each> |
| <cloneNode obj="employeeNode" deep="true" var="clonedNode"/> |
| <childNodes obj="clonedNode" var="clonedList"/> |
| <for-each collection="clonedList" member="clonedChild"> |
| <nodeName obj="clonedChild" var="clonedChildName"/> |
| <append collection="result" item="clonedChildName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expected" id="clone" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeclonetruecopytext.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeclonetruecopytext"> |
| <metadata> |
| <title>hc_nodeCloneTrueCopyText</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "cloneNode(deep)" method does not copy text unless it |
| is deep cloned.(Test for deep=true) |
| Retrieve the eighth child of the second employee and |
| the "cloneNode(deep)" method with deep=true. The |
| duplicate node returned by the method should copy |
| any text data contained in this node. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="childNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="lastChildNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"sup"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="childNode"/> |
| <cloneNode obj="childNode" deep="true" var="clonedNode"/> |
| <lastChild interface="Node" obj="clonedNode" var="lastChildNode"/> |
| <nodeValue obj="lastChildNode" var="childValue"/> |
| <assertEquals actual="childValue" expected='"35,000"' id="cloneContainsText" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodecommentnodeattributes.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodecommentnodeattributes"> |
| <metadata> |
| <title>hc_nodeCommentNodeAttributes</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getAttributes()" method invoked on a Comment |
| Node returns null. |
| Find any comment that is an immediate child of the root |
| and assert that Node.attributes is null. Then create |
| a new comment node (in case they had been omitted) and |
| make the assertion. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1728279322"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=248"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=263"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="commentNode" type="Node"/> |
| <var name="nodeList" type="NodeList"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <childNodes obj="doc" var="nodeList"/> |
| <for-each collection="nodeList" member="commentNode"> |
| <nodeType obj="commentNode" var="nodeType"/> |
| <if> |
| <equals actual="nodeType" expected="8" ignoreCase="false"/> |
| <attributes obj="commentNode" var="attrList"/> |
| <assertNull actual="attrList" id="existingCommentAttributesNull"/> |
| </if> |
| </for-each> |
| <createComment var="commentNode" obj="doc" data='"This is a comment"'/> |
| <attributes obj="commentNode" var="attrList"/> |
| <assertNull actual="attrList" id="createdCommentAttributesNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodecommentnodename.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodecommentnodename"> |
| <metadata> |
| <title>hc_nodeCommentNodeName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| Comment Node is "#comment". |
| Retrieve the Comment node in the XML file |
| and check the string returned by the "getNodeName()" |
| method. It should be equal to "#comment". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1728279322"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=248"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="commentNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="commentName" type="DOMString"/> |
| <var name="commentNodeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <childNodes obj="doc" var="elementList"/> |
| <for-each collection="elementList" member="commentNode"> |
| <nodeType obj="commentNode" var="nodeType"/> |
| <if> |
| <equals actual="nodeType" expected="8" ignoreCase="false"/> |
| <nodeName obj="commentNode" var="commentNodeName"/> |
| <assertEquals actual="commentNodeName" expected='"#comment"' id="existingNodeName" ignoreCase="false"/> |
| </if> |
| </for-each> |
| <createComment var="commentNode" obj="doc" data='"This is a comment"'/> |
| <nodeName obj="commentNode" var="commentNodeName"/> |
| <assertEquals actual="commentNodeName" expected='"#comment"' id="createdNodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodecommentnodetype.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodecommentnodetype"> |
| <metadata> |
| <title>hc_nodeCommentNodeType</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getNodeType()" method for a Comment Node |
| returns the constant value 8. |
| Retrieve the nodes from the document and check for |
| a comment node and invoke the "getNodeType()" method. This should |
| return 8. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1728279322"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=248"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="testList" type="NodeList"/> |
| <var name="commentNode" type="Node"/> |
| <var name="commentNodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <childNodes obj="doc" var="testList"/> |
| <for-each collection="testList" member="commentNode"> |
| <nodeName obj="commentNode" var="commentNodeName"/> |
| <if> |
| <equals actual="commentNodeName" expected='"#comment"' ignoreCase="false"/> |
| <nodeType obj="commentNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="8" id="existingCommentNodeType" ignoreCase="false"/> |
| </if> |
| </for-each> |
| <createComment var="commentNode" obj="doc" data='"This is a comment"'/> |
| <nodeType obj="commentNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="8" id="createdCommentNodeType" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodecommentnodevalue.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodecommentnodevalue"> |
| <metadata> |
| <title>hc_nodeCommentNodeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| Comment Node is the content of the comment. |
| Retrieve the comment in the XML file and |
| check the string returned by the "getNodeValue()" method. |
| It should be equal to "This is comment number 1". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1728279322"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=248"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="commentNode" type="Node"/> |
| <var name="commentName" type="DOMString"/> |
| <var name="commentValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <childNodes obj="doc" var="elementList"/> |
| <for-each collection="elementList" member="commentNode"> |
| <nodeName obj="commentNode" var="commentName"/> |
| <if> |
| <equals actual="commentName" expected='"#comment"' ignoreCase="false"/> |
| <nodeValue obj="commentNode" var="commentValue"/> |
| <assertEquals actual="commentValue" expected='" This is comment number 1."' id="value" ignoreCase="false"/> |
| </if> |
| </for-each> |
| <createComment var="commentNode" obj="doc" data='" This is a comment"'/> |
| <nodeValue obj="commentNode" var="commentValue"/> |
| <assertEquals actual="commentValue" expected='" This is a comment"' id="createdCommentNodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodedocumentfragmentnodename.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodedocumentfragmentnodename"> |
| <metadata> |
| <title>hc_nodeDocumentFragmentNodeName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| DocumentFragment Node is "#document-frament". |
| Retrieve the DOM document and invoke the |
| "createDocumentFragment()" method and check the string |
| returned by the "getNodeName()" method. It should be |
| equal to "#document-fragment". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A3"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="documentFragmentName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="docFragment"/> |
| <nodeName obj="docFragment" var="documentFragmentName"/> |
| <assertEquals actual="documentFragmentName" expected='"#document-fragment"' id="nodeDocumentFragmentNodeNameAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodedocumentfragmentnodetype.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodedocumentfragmentnodetype"> |
| <metadata> |
| <title>hc_nodeDocumentFragmentNodeType</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getNodeType()" method for a DocumentFragment Node |
| returns the constant value 11. |
| Invoke the "createDocumentFragment()" method and |
| examine the NodeType of the document fragment |
| returned by the "getNodeType()" method. The method |
| should return 11. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A3"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="documentFragmentNode" type="DocumentFragment"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="documentFragmentNode"/> |
| <nodeType obj="documentFragmentNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="11" id="nodeDocumentFragmentNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodedocumentfragmentnodevalue.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodedocumentfragmentnodevalue"> |
| <metadata> |
| <title>hc_nodeDocumentFragmentNodeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| DocumentFragment Node is null. |
| Retrieve the DOM document and invoke the |
| "createDocumentFragment()" method and check the string |
| returned by the "getNodeValue()" method. It should be |
| equal to null. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A3"/> |
| <!--nodeValue attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <!-- Node.attributes --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="docFragment"/> |
| <!-- despite the name, this was the only assertion in the original test --> |
| <attributes obj="docFragment" var="attrList"/> |
| <assertNull actual="attrList" id="attributesNull"/> |
| <!-- now actually test the initial value of nodeValue --> |
| <nodeValue obj="docFragment" var="value"/> |
| <assertNull actual="value" id="initiallyNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodedocumentnodeattribute.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodedocumentnodeattribute"> |
| <metadata> |
| <title>hc_nodedocumentnodeattribute</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getAttributes()" method invoked on a Document |
| Node returns null. |
| Retrieve the DOM Document and invoke the |
| "getAttributes()" method on the Document Node. |
| It should return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- Document interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <attributes obj="doc" var="attrList"/> |
| <assertNull actual="attrList" id="doc_attributes_is_null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodedocumentnodename.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodedocumentnodename"> |
| <metadata> |
| <title>hc_nodeDocumentNodeName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| Document Node is "#document". |
| Retrieve the DOM document and check the string returned |
| by the "getNodeName()" method. It should be equal to |
| "#document". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!-- Document interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="documentName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <nodeName obj="doc" var="documentName"/> |
| <assertEquals actual="documentName" expected='"#document"' id="documentNodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodedocumentnodetype.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodedocumentnodetype"> |
| <metadata> |
| <title>hc_nodeDocumentNodeType</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getNodeType()" method for a Document Node |
| returns the constant value 9. |
| Retrieve the document and invoke the "getNodeType()" |
| method. The method should return 9. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!-- Document interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <nodeType obj="doc" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="9" id="nodeDocumentNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodedocumentnodevalue.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodedocumentnodevalue"> |
| <metadata> |
| <title>hc_nodeDocumentNodeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| Document Node is null. |
| Retrieve the DOM Document and check the string returned |
| by the "getNodeValue()" method. It should be equal to |
| null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!-- Document interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="documentValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <nodeValue obj="doc" var="documentValue"/> |
| <assertNull actual="documentValue" id="documentNodeValue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeelementnodeattributes.xml.kfail |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeelementnodeattributes"> |
| <metadata> |
| <title>hc_nodeelementnodeattributes</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the third "acronym" element and evaluate Node.attributes. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=236"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Jun/0011.html"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=184"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="NamedNodeMap"/> |
| <var name="attrNode" type="Node"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="attrList" type="Collection"/> |
| <var name="htmlExpected" type="Collection"> |
| <member>"title"</member> |
| <member>"class"</member> |
| </var> |
| <var name="expected" type="Collection"> |
| <member>"title"</member> |
| <member>"class"</member> |
| <member>"dir"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testAddr"/> |
| <attributes obj="testAddr" var="addrAttr"/> |
| <for-each collection="addrAttr" member="attrNode"> |
| <nodeName obj="attrNode" var="attrName"/> |
| <append collection="attrList" item="attrName"/> |
| </for-each> |
| <if><contentType type="text/html"/> |
| <assertEquals actual="attrList" expected="htmlExpected" id="attrNames_html" |
| ignoreCase="true"/> |
| <else> |
| <assertEquals actual="attrList" expected="expected" id="attrNames" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeelementnodename.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeelementnodename"> |
| <metadata> |
| <title>hc_nodeelementnodename</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the first Element Node(Root Node) of the |
| DOM object and check the string returned by the |
| "getNodeName()" method. It should be equal to its |
| tagName. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=251"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementNode" type="Element"/> |
| <var name="elementName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement obj="doc" var="elementNode"/> |
| <nodeName obj="elementNode" var="elementName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="elementName" expected='"svg"' id="svgNodeName" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="elementName" expected='"html"' id="nodeName" ignoreCase="auto"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeelementnodetype.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeelementnodetype"> |
| <metadata> |
| <title>hc_nodeElementNodeType</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getNodeType()" method for an Element Node |
| returns the constant value 1. |
| Retrieve the root node and invoke the "getNodeType()" |
| method. The method should return 1. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Element"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <nodeType obj="rootNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="1" id="nodeElementNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeelementnodevalue.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeelementnodevalue"> |
| <metadata> |
| <title>hc_nodeElementNodeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for an |
| Element Node is null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementNode" type="Element"/> |
| <var name="elementValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement obj="doc" var="elementNode"/> |
| <nodeValue obj="elementNode" var="elementValue"/> |
| <assertNull actual="elementValue" id="elementNodeValue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodegetfirstchild.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodegetfirstchild"> |
| <metadata> |
| <title>hc_nodeGetFirstChild</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getFirstChild()" method returns the first child |
| of this node. |
| Retrieve the second employee and invoke the |
| "getFirstChild()" method. The NodeName returned |
| should be "#text" or "EM". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-169727388"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="fchildNode" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <firstChild interface="Node" obj="employeeNode" var="fchildNode"/> |
| <nodeName obj="fchildNode" var="childName"/> |
| <if><equals expected='"#text"' actual="childName"/> |
| <assertEquals actual="childName" expected='"#text"' id="firstChild_w_whitespace" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="childName" expected='"em"' id="firstChild_wo_whitespace" ignoreCase="auto"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodegetfirstchildnull.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodegetfirstchildnull"> |
| <metadata> |
| <title>hc_nodeGetFirstChildNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If there is not a first child then the "getFirstChild()" |
| method returns null. |
| Retrieve the text of the first "em" element and invoke the "getFirstChild()" method. It |
| should return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-169727388"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="emList" type="NodeList"/> |
| <var name="emNode" type="Node"/> |
| <var name="emText" type="CharacterData"/> |
| <var name="nullChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"em"' var="emList"/> |
| <item interface="NodeList" obj="emList" index="0" var="emNode"/> |
| <firstChild var="emText" obj="emNode" interface="Node"/> |
| <firstChild var="nullChild" obj="emText" interface="Node"/> |
| <assertNull actual="nullChild" id="nullChild"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodegetlastchild.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodegetlastchild"> |
| <metadata> |
| <title>hc_nodeGetLastChild</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getLastChild()" method returns the last child |
| of this node. |
| Retrieve the second employee and invoke the |
| "getLastChild()" method. The NodeName returned |
| should be "#text". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-61AD09FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="lchildNode" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <lastChild interface="Node" obj="employeeNode" var="lchildNode"/> |
| <nodeName obj="lchildNode" var="childName"/> |
| <assertEquals actual="childName" expected='"#text"' id="whitespace" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodegetlastchildnull.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodegetlastchildnull"> |
| <metadata> |
| <title>hc_nodeGetLastChildNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If there is not a last child then the "getLastChild()" |
| method returns null. |
| Retrieve the text of the first "em" element and invoke the "getFirstChild()" method. It |
| should return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-61AD09FB"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="emList" type="NodeList"/> |
| <var name="emNode" type="Node"/> |
| <var name="emText" type="CharacterData"/> |
| <var name="nullChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"em"' var="emList"/> |
| <item interface="NodeList" obj="emList" index="0" var="emNode"/> |
| <firstChild var="emText" obj="emNode" interface="Node"/> |
| <lastChild var="nullChild" obj="emText" interface="Node"/> |
| <assertNull actual="nullChild" id="nullChild"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodegetnextsibling.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodegetnextsibling"> |
| <metadata> |
| <title>hc_nodeGetNextSibling</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getNextSibling()" method returns the node immediately |
| following this node. |
| Retrieve the first child of the second employee and |
| invoke the "getNextSibling()" method. It should return |
| a node with the NodeName of "#text". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6AC54C2F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="emNode" type="Node"/> |
| <var name="nsNode" type="Node"/> |
| <var name="nsName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"em"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="emNode"/> |
| <nextSibling interface="Node" obj="emNode" var="nsNode"/> |
| <nodeName obj="nsNode" var="nsName"/> |
| <assertEquals actual="nsName" expected='"#text"' id="whitespace" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodegetnextsiblingnull.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodegetnextsiblingnull"> |
| <metadata> |
| <title>hc_nodeGetNextSiblingNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If there is not a node immediately following this node the |
| "getNextSibling()" method returns null. |
| Retrieve the first child of the second employee and |
| invoke the "getNextSibling()" method. It should |
| be set to null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6AC54C2F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="lcNode" type="Node"/> |
| <var name="nsNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <lastChild interface="Node" obj="employeeNode" var="lcNode"/> |
| <nextSibling interface="Node" obj="lcNode" var="nsNode"/> |
| <assertNull actual="nsNode" id="nodeGetNextSiblingNullAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodegetownerdocument.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodegetownerdocument"> |
| <metadata> |
| <title>hc_nodegetownerdocument</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Evaluate Node.ownerDocument on the second "p" element. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#node-ownerDoc"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=251"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="docNode" type="Node"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docElement" type="Element"/> |
| <var name="elementName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="docNode"/> |
| <ownerDocument obj="docNode" var="ownerDocument"/> |
| <documentElement obj="ownerDocument" var="docElement"/> |
| <nodeName obj="docElement" var="elementName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="elementName" expected='"svg"' id="svgNodeName" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="elementName" expected='"html"' id="ownerDocElemTagName" ignoreCase="auto"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodegetownerdocumentnull.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodegetownerdocumentnull"> |
| <metadata> |
| <title>hc_nodeGetOwnerDocumentNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getOwnerDocument()" method returns null if the target |
| node itself is a document. |
| Invoke the "getOwnerDocument()" method on the master |
| document. The Document returned should be null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#node-ownerDoc"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="ownerDocument" type="Document"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <ownerDocument obj="doc" var="ownerDocument"/> |
| <assertNull actual="ownerDocument" id="nodeGetOwnerDocumentNullAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodegetprevioussibling.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodegetprevioussibling"> |
| <metadata> |
| <title>hc_nodeGetPreviousSibling</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getPreviousSibling()" method returns the node |
| immediately preceding this node. |
| Retrieve the second child of the second employee and |
| invoke the "getPreviousSibling()" method. It should |
| return a node with a NodeName of "#text". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-640FB3C8"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="psNode" type="Node"/> |
| <var name="psName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"strong"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="nameNode"/> |
| <previousSibling interface="Node" obj="nameNode" var="psNode"/> |
| <nodeName obj="psNode" var="psName"/> |
| <assertEquals actual="psName" expected='"#text"' id="whitespace" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodegetprevioussiblingnull.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodegetprevioussiblingnull"> |
| <metadata> |
| <title>hc_nodeGetPreviousSiblingNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If there is not a node immediately preceding this node the |
| "getPreviousSibling()" method returns null. |
| Retrieve the first child of the second employee and |
| invoke the "getPreviousSibling()" method. It should |
| be set to null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-640FB3C8"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="fcNode" type="Node"/> |
| <var name="psNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="employeeNode"/> |
| <firstChild interface="Node" obj="employeeNode" var="fcNode"/> |
| <previousSibling interface="Node" obj="fcNode" var="psNode"/> |
| <assertNull actual="psNode" id="nodeGetPreviousSiblingNullAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodehaschildnodes.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodehaschildnodes"> |
| <metadata> |
| <title>hc_nodeHasChildNodes</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "hasChildNodes()" method returns true if the node |
| has children. |
| Retrieve the root node("staff") and invoke the |
| "hasChildNodes()" method. It should return the boolean |
| value "true". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-810594187"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <hasChildNodes obj="employeeNode" var="state"/> |
| <assertTrue actual="state" id="nodeHasChildAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodehaschildnodesfalse.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodehaschildnodesfalse"> |
| <metadata> |
| <title>hc_nodeHasChildNodesFalse</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "hasChildNodes()" method returns false if the node |
| does not have any children. |
| Retrieve the text of the first "em" element and invoke the "hasChildNodes()" method. It |
| should return false. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-810594187"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="emList" type="NodeList"/> |
| <var name="emNode" type="Node"/> |
| <var name="emText" type="CharacterData"/> |
| <var name="hasChild" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"em"' var="emList"/> |
| <item interface="NodeList" obj="emList" index="0" var="emNode"/> |
| <firstChild var="emText" obj="emNode" interface="Node"/> |
| <hasChildNodes var="hasChild" obj="emText" interface="Node"/> |
| <assertFalse actual="hasChild" id="hasChild"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeinsertbefore.xml |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeinsertbefore"> |
| <metadata> |
| <title>hc_nodeInsertBefore</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method inserts the |
| node "newChild" before the node "refChild". |
| Insert a newly created Element node before the second |
| sup element in the document and check the "newChild" |
| and "refChild" after insertion for correct placement. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=261"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="insertedNode" type="Node"/> |
| <var name="actual" type="List"/> |
| <var name="expected" type="List"> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"br"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| </var> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"sup"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="refChild"/> |
| <parentNode interface="Node" var="employeeNode" obj="refChild"/> |
| <childNodes var="childList" obj="employeeNode"/> |
| <createElement obj="doc" tagName='"br"' var="newChild"/> |
| <insertBefore var="insertedNode" obj="employeeNode" newChild="newChild" refChild="refChild"/> |
| <for-each collection="childList" member="child"> |
| <nodeType var="nodeType" obj="child"/> |
| <if><equals actual="nodeType" expected="1"/> |
| <nodeName obj="child" var="childName"/> |
| <append collection="actual" item="childName"/> |
| </if> |
| </for-each> |
| <assertEquals actual="actual" expected="expected" id="nodeNames" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeinsertbeforedocfragment.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeinsertbeforedocfragment"> |
| <metadata> |
| <title>hc_nodeInsertBeforeDocFragment</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the "newChild" is a DocumentFragment object then all |
| its children are inserted in the same order before the |
| the "refChild". |
| Create a DocumentFragment object and populate it with |
| two Element nodes. Retrieve the second employee and |
| insert the newly created DocumentFragment before its |
| fourth child. The second employee should now have two |
| extra children("newChild1" and "newChild2") at |
| positions fourth and fifth respectively. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="newdocFragment" type="DocumentFragment"/> |
| <var name="newChild1" type="Node"/> |
| <var name="newChild2" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="3" var="refChild"/> |
| <createDocumentFragment obj="doc" var="newdocFragment"/> |
| <createElement obj="doc" tagName='"br"' var="newChild1"/> |
| <createElement obj="doc" tagName='"b"' var="newChild2"/> |
| <appendChild var="appendedChild" obj="newdocFragment" newChild="newChild1"/> |
| <appendChild var="appendedChild" obj="newdocFragment" newChild="newChild2"/> |
| <insertBefore var="insertedNode" obj="employeeNode" newChild="newdocFragment" refChild="refChild"/> |
| <item interface="NodeList" obj="childList" index="3" var="child"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"br"' ignoreCase="auto" id="childName3"/> |
| <item interface="NodeList" obj="childList" index="4" var="child"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"b"' ignoreCase="auto" id="childName4"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeinsertbeforeinvalidnodetype.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeinsertbeforeinvalidnodetype"> |
| <metadata> |
| <title>hc_nodeInsertBeforeInvalidNodeType</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if this node is of |
| a type that does not allow children of the type "newChild" |
| to be inserted. |
| Retrieve the root node and attempt to insert a newly |
| created Attr node. An Element node cannot have children |
| of the "Attr" type, therefore the desired exception |
| should be raised. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-952280727')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=406"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Element"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttribute obj="doc" name='"title"' var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="refChild"/> |
| <parentNode var="rootNode" obj="refChild" interface="Node"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore var="insertedNode" obj="rootNode" newChild="newChild" refChild="refChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeinsertbeforenewchilddiffdocument.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeinsertbeforenewchilddiffdocument"> |
| <metadata> |
| <title>hc_nodeInsertBeforeNewChildDiffDocument</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method raises a |
| WRONG_DOCUMENT_ERR DOMException if the "newChild" was |
| created from a different document than the one that |
| created this node. |
| Retrieve the second employee and attempt to insert a new |
| child that was created from a different document than the |
| one that created the second employee. An attempt to |
| insert such a child should raise the desired exception. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-952280727')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="refChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <load var="doc2" href="hc_staff" willBeModified="true"/> |
| <createElement obj="doc1" tagName='"br"' var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc2" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <firstChild var="refChild" obj="elementNode" interface="Node"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <insertBefore var="insertedNode" obj="elementNode" newChild="newChild" refChild="refChild"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeinsertbeforenewchildexists.xml |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeinsertbeforenewchildexists"> |
| <metadata> |
| <title>hc_nodeInsertBeforeNewChildExists</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the "newChild" is already in the tree, the |
| "insertBefore(newChild,refChild)" method must first |
| remove it before the insertion takes place. |
| Insert a node Element ("em") that is already |
| present in the tree. The existing node should be |
| removed first and the new one inserted. The node is |
| inserted at a different position in the tree to assure |
| that it was indeed inserted. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="insertedNode" type="Node"/> |
| <var name="expected" type="List"> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"em"</member> |
| <member>"acronym"</member> |
| </var> |
| <var name="result" type="List"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <getElementsByTagName interface="Element" obj="employeeNode" tagname='"*"' var="childList"/> |
| <item interface="NodeList" obj="childList" index="5" var="refChild"/> |
| <item interface="NodeList" obj="childList" index="0" var="newChild"/> |
| <insertBefore var="insertedNode" obj="employeeNode" newChild="newChild" refChild="refChild"/> |
| <for-each collection="childList" member="child"> |
| <nodeType obj="child" var="nodeType"/> |
| <if><equals actual="nodeType" expected="1"/> |
| <nodeName obj="child" var="childName"/> |
| <append collection="result" item="childName"/> |
| </if> |
| </for-each> |
| <assertEquals id="childNames" actual="result" expected="expected" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeinsertbeforenodeancestor.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeinsertbeforenodeancestor"> |
| <metadata> |
| <title>hc_nodeInsertBeforeNodeAncestor</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if the node to be |
| inserted is one of this nodes ancestors. |
| Retrieve the second employee and attempt to insert a |
| node that is one of its ancestors(root node). An |
| attempt to insert such a node should raise the |
| desired exception. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-952280727')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement obj="doc" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="0" var="refChild"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore var="insertedNode" obj="employeeNode" newChild="newChild" refChild="refChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeinsertbeforenodename.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeinsertbeforenodename"> |
| <metadata> |
| <title>hc_nodeInsertBeforeNodeName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertBefore(newChild,refchild)" method returns |
| the node being inserted. |
| Insert an Element node before the fourth |
| child of the second employee and check the node |
| returned from the "insertBefore(newChild,refChild)" |
| method. The node returned should be "newChild". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="3" var="refChild"/> |
| <createElement obj="doc" tagName='"br"' var="newChild"/> |
| <insertBefore obj="employeeNode" newChild="newChild" refChild="refChild" var="insertedNode"/> |
| <nodeName obj="insertedNode" var="childName"/> |
| <assertEquals actual="childName" expected='"br"' id="nodeName" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeinsertbeforerefchildnonexistent.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeinsertbeforerefchildnonexistent"> |
| <metadata> |
| <title>hc_nodeInsertBeforeRefChildNonexistent</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method raises a |
| NOT_FOUND_ERR DOMException if the reference child is |
| not a child of this node. |
| Retrieve the second employee and attempt to insert a |
| new node before a reference node that is not a child |
| of this node. An attempt to insert before a non child |
| node should raise the desired exception. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-952280727')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="refChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElement obj="doc" tagName='"br"' var="newChild"/> |
| <createElement obj="doc" tagName='"b"' var="refChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <insertBefore var="insertedNode" obj="elementNode" newChild="newChild" refChild="refChild"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeinsertbeforerefchildnull.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeinsertbeforerefchildnull"> |
| <metadata> |
| <title>hc_nodeInsertBeforeRefChildNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the "refChild" is null then the |
| "insertBefore(newChild,refChild)" method inserts the |
| node "newChild" at the end of the list of children. |
| Retrieve the second employee and invoke the |
| "insertBefore(newChild,refChild)" method with |
| refChild=null. Since "refChild" is null the "newChild" |
| should be added to the end of the list. The last item |
| in the list is checked after insertion. The last Element |
| node of the list should be "newChild". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node" isNull="true"/> |
| <var name="newChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <createElement obj="doc" tagName='"br"' var="newChild"/> |
| <insertBefore var="insertedNode" obj="employeeNode" newChild="newChild" refChild="refChild"/> |
| <lastChild interface="Node" obj="employeeNode" var="child"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"br"' id="nodeName" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodelistindexequalzero.xml.int-broken |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodelistindexequalzero"> |
| <metadata> |
| <title>hc_nodelistIndexEqualZero</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a list of all the children elements of the third |
| employee and access its first child by using an index |
| of 0. This should result in the whitspace before "em" being |
| selected (em when ignoring whitespace). |
| Further we evaluate its content(by using |
| the "getNodeName()" method) to ensure the proper |
| element was accessed. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--item--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-844377136"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"p"'/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <length var="length" obj="employeeList" interface="NodeList"/> |
| <item interface="NodeList" obj="employeeList" var="child" index="0"/> |
| <nodeName obj="child" var="childName"/> |
| <if><equals expected='13' actual="length" ignoreCase="false"/> |
| <assertEquals actual="childName" expected='"#text"' ignoreCase="false" id="childName_w_whitespace"/> |
| <else> |
| <assertEquals actual="childName" expected='"em"' ignoreCase="auto" id="childName_wo_whitespace"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodelistindexgetlength.xml.int-broken |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodelistindexgetlength"> |
| <metadata> |
| <title>hc_nodelistIndexGetLength</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getLength()" method returns the number of nodes |
| in the list. |
| Create a list of all the children elements of the third |
| employee and invoke the "getLength()" method. |
| It should contain the value 13. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--length attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-203510337"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"p"'/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <length var="length" obj="employeeList" interface="NodeList"/> |
| <if><equals actual="length" expected="6"/> |
| <assertEquals actual="length" expected="6" ignoreCase="false" id="length_wo_space"/> |
| <else> |
| <assertEquals actual="length" expected="13" ignoreCase="false" id="length_w_space"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodelistindexgetlengthofemptylist.xml.int-broken |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodelistindexgetlengthofemptylist"> |
| <metadata> |
| <title>hc_nodelistIndexGetLengthOfEmptyList</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getLength()" method returns the number of nodes |
| in the list.(Test for EMPTY list) |
| Create a list of all the children of the Text node |
| inside the first child of the third employee and |
| invoke the "getLength()" method. It should contain |
| the value 0. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--length attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-203510337"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="emList" type="NodeList"/> |
| <var name="emNode" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="textList" type="NodeList"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="emList" tagname='"em"'/> |
| <item interface="NodeList" obj="emList" var="emNode" index="2"/> |
| <firstChild var="textNode" obj="emNode"/> |
| <childNodes var="textList" obj="textNode"/> |
| <length var="length" obj="textList" interface="NodeList"/> |
| <assertEquals actual="length" expected="0" id="length" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodelistindexnotzero.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodelistindexnotzero"> |
| <metadata> |
| <title>hc_nodelistIndexNotZero</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The items in the list are accessible via an integral |
| index starting from zero. |
| (Index not equal 0) |
| Create a list of all the children elements of the third |
| employee and access its fourth child by using an index |
| of 3 and calling getNodeName() which should return |
| "strong" (no whitespace) or "#text" (with whitespace). |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--item--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-844377136"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"p"'/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <item interface="NodeList" obj="employeeList" var="child" index="3"/> |
| <nodeName obj="child" var="childName"/> |
| <if><equals expected='"#text"' actual="childName"/> |
| <assertEquals id="childName_space" actual="childName" expected='"#text"' ignoreCase="false"/> |
| <else> |
| <assertEquals id="childName_strong" actual="childName" expected='"strong"' ignoreCase="auto"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodelistreturnfirstitem.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodelistreturnfirstitem"> |
| <metadata> |
| <title>hc_nodelistReturnFirstItem</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a list of all the children elements of the third |
| employee and access its first child by invoking the |
| "item(index)" method with an index=0. This should |
| result in node with a nodeName of "#text" or "em". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-844377136"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"p"'/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <item interface="NodeList" obj="employeeList" var="child" index="0"/> |
| <nodeName obj="child" var="childName"/> |
| <if><equals actual="childName" expected='"#text"'/> |
| <assertEquals actual="childName" expected='"#text"' ignoreCase="false" id="nodeName_w_space"/> |
| <else> |
| <assertEquals actual="childName" expected='"em"' ignoreCase="auto" id="nodeName_wo_space"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodelistreturnlastitem.xml.int-broken |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodelistreturnlastitem"> |
| <metadata> |
| <title>hc_nodelistReturnLastItem</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a list of all the children elements of the third |
| employee and access its last child by invoking the |
| "item(index)" method with an index=length-1. This should |
| result in node with nodeName="#text" or acronym.</description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-844377136"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="index" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"p"'/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <length var="index" obj="employeeList" interface="NodeList"/> |
| <decrement var="index" value="1"/> |
| <item interface="NodeList" obj="employeeList" var="child" index="index"/> |
| <nodeName obj="child" var="childName"/> |
| <if><equals actual="index" expected="12"/> |
| <assertEquals actual="childName" expected='"#text"' id="lastNodeName_w_whitespace" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="childName" expected='"acronym"' id="lastNodeName" ignoreCase="auto"/> |
| <assertEquals actual="index" expected="5" id="index" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodelisttraverselist.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodelisttraverselist"> |
| <metadata> |
| <title>hc_nodelistTraverseList</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The range of valid child node indices is 0 thru length -1 |
| Create a list of all the children elements of the third |
| employee and traverse the list from index=0 thru |
| length -1. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--length attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-203510337"/> |
| <!--item--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-844377136"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="result" type="List"/> |
| <var name="expected" type="List"> |
| <member>"em"</member> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"p"'/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <for-each collection="employeeList" member="child"> |
| <nodeType var="nodeType" obj="child"/> |
| <nodeName obj="child" var="childName"/> |
| <if><equals actual="nodeType" expected="1"/> |
| <append collection="result" item="childName"/> |
| <else> |
| <assertEquals actual="nodeType" expected="3" id="textNodeType" ignoreCase="false"/> |
| <assertEquals actual="childName" expected='"#text"' id="textNodeName" ignoreCase="false"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="result" expected="expected" id="nodeNames" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeparentnode.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeparentnode"> |
| <metadata> |
| <title>hc_nodeParentNode</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getParentNode()" method returns the parent |
| of this node. |
| Retrieve the second employee and invoke the |
| "getParentNode()" method on this node. It should |
| be set to "body". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1060184317"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="parentNode" type="Node"/> |
| <var name="parentName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <parentNode interface="Node" obj="employeeNode" var="parentNode"/> |
| <nodeName obj="parentNode" var="parentName"/> |
| <assertEquals actual="parentName" expected='"body"' id="parentNodeName" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodeparentnodenull.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodeparentnodenull"> |
| <metadata> |
| <title>hc_nodeParentNodeNull</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getParentNode()" method invoked on a node that has |
| just been created and not yet added to the tree is null. |
| Create a new "employee" Element node using the |
| "createElement(name)" method from the Document interface. |
| Since this new node has not yet been added to the tree, |
| the "getParentNode()" method will return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1060184317"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="createdNode" type="Element"/> |
| <var name="parentNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElement obj="doc" tagName='"br"' var="createdNode"/> |
| <parentNode interface="Node" obj="createdNode" var="parentNode"/> |
| <assertNull actual="parentNode" id="parentNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_noderemovechild.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_noderemovechild"> |
| <metadata> |
| <title>hc_nodeRemoveChild</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeChild(oldChild)" method removes the child node |
| indicated by "oldChild" from the list of children and |
| returns it. |
| Remove the first employee by invoking the |
| "removeChild(oldChild)" method an checking the |
| node returned by the "getParentNode()" method. It |
| should be set to null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="childToRemove" type="Node"/> |
| <var name="removedChild" type="Node"/> |
| <var name="parentNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <childNodes obj="rootNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="1" var="childToRemove"/> |
| <removeChild obj="rootNode" var="removedChild" oldChild="childToRemove"/> |
| <parentNode interface="Node" obj="removedChild" var="parentNode"/> |
| <assertNull actual="parentNode" id="parentNodeNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_noderemovechildgetnodename.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_noderemovechildgetnodename"> |
| <metadata> |
| <title>hc_nodeRemoveChildGetNodeName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeChild(oldChild)" method returns |
| the node being removed. |
| Remove the first child of the second employee |
| and check the NodeName returned by the |
| "removeChild(oldChild)" method. The returned node |
| should have a NodeName equal to "#text". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="removedChild" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="oldName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="0" var="oldChild"/> |
| <nodeName obj="oldChild" var="oldName"/> |
| <removeChild obj="employeeNode" oldChild="oldChild" var="removedChild"/> |
| <assertNotNull actual="removedChild" id="notnull"/> |
| <nodeName obj="removedChild" var="childName"/> |
| <assertEquals actual="childName" expected='oldName' id="nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_noderemovechildnode.xml |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_noderemovechildnode"> |
| <metadata> |
| <title>hc_noderemovechildnode</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeChild(oldChild)" method removes the node |
| indicated by "oldChild". |
| Retrieve the second p element and remove its first child. |
| After the removal, the second p element should have 5 element |
| children and the first child should now be the child |
| that used to be at the second position in the list. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="emList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="length" type="int"/> |
| <var name="removedChild" type="Node"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="expected" type="List"> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"acronym"</member> |
| </var> |
| <var name="actual" type="List"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <getElementsByTagName interface="Element" var="emList" obj="employeeNode" tagname='"em"'/> |
| <item interface="NodeList" obj="emList" index="0" var="oldChild"/> |
| <removeChild var="removedChild" obj="employeeNode" oldChild="oldChild"/> |
| <nodeName obj="removedChild" var="removedName"/> |
| <assertEquals actual="removedName" expected='"em"' ignoreCase="auto" id="removedName"/> |
| <for-each collection="childList" member="child"> |
| <nodeType var="nodeType" obj="child"/> |
| <nodeName var="childName" obj="child"/> |
| <if><equals expected="1" actual="nodeType"/> |
| <append collection="actual" item="childName"/> |
| <else> |
| <assertEquals expected="3" actual="nodeType" id="textNodeType" ignoreCase="false"/> |
| <assertEquals expected='"#text"' actual="childName" id="textNodeName" ignoreCase="false"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="actual" expected='expected' ignoreCase="auto" id="childNames"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_noderemovechildoldchildnonexistent.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_noderemovechildoldchildnonexistent"> |
| <metadata> |
| <title>hc_nodeRemoveChildOldChildNonexistent</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeChild(oldChild)" method raises a |
| NOT_FOUND_ERR DOMException if the old child is |
| not a child of this node. |
| Retrieve the second employee and attempt to remove a |
| node that is not one of its children. An attempt to |
| remove such a node should raise the desired exception. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1734834066')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="oldChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="removedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElement obj="doc" tagName='"br"' var="oldChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild var="removedChild" obj="elementNode" oldChild="oldChild"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodereplacechild.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodereplacechild"> |
| <metadata> |
| <title>hc_nodeReplaceChild</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method replaces |
| the node "oldChild" with the node "newChild". |
| Replace the first element of the second employee with |
| a newly created Element node. Check the first position |
| after the replacement operation is completed. The new |
| Element should be "newChild". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="replacedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="0" var="oldChild"/> |
| <createElement obj="doc" tagName='"br"' var="newChild"/> |
| <replaceChild var="replacedNode" obj="employeeNode" newChild="newChild" oldChild="oldChild"/> |
| <item interface="NodeList" obj="childList" index="0" var="child"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"br"' id="nodeName" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodereplacechildinvalidnodetype.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodereplacechildinvalidnodetype"> |
| <metadata> |
| <title>hc_nodeReplaceChildInvalidNodeType</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if this node is of |
| a type that does not allow children of the type "newChild" |
| to be inserted. |
| Retrieve the root node and attempt to replace |
| one of its children with a newly created Attr node. |
| An Element node cannot have children of the "Attr" |
| type, therefore the desired exception should be raised. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=406"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Element"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="replacedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttribute obj="doc" name='"lang"' var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="oldChild"/> |
| <parentNode var="rootNode" obj="oldChild" interface="Node"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <replaceChild var="replacedChild" obj="rootNode" newChild="newChild" oldChild="oldChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodereplacechildnewchilddiffdocument.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodereplacechildnewchilddiffdocument"> |
| <metadata> |
| <title>hc_nodeReplaceChildNewChildDiffDocument</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method raises a |
| WRONG_DOCUMENT_ERR DOMException if the "newChild" was |
| created from a different document than the one that |
| created this node. |
| Retrieve the second employee and attempt to replace one |
| of its children with a node created from a different |
| document. An attempt to make such a replacement |
| should raise the desired exception. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="oldChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="replacedChild" type="Node"/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <load var="doc2" href="hc_staff" willBeModified="true"/> |
| <createElement obj="doc1" tagName='"br"' var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc2" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <firstChild obj="elementNode" var="oldChild" interface="Node"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <replaceChild var="replacedChild" obj="elementNode" newChild="newChild" oldChild="oldChild"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodereplacechildnewchildexists.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodereplacechildnewchildexists"> |
| <metadata> |
| <title>hc_nodeReplaceChildNewChildExists</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the "newChild" is already in the tree, it is first |
| removed before the new one is added. |
| Retrieve the second "p" and replace "acronym" with its "em". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=246"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node" isNull="true"/> |
| <var name="newChild" type="Node" isNull="true"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="childNode" type="Node"/> |
| <var name="actual" type="List"/> |
| <var name="expected" type="List"> |
| <member>"strong"</member> |
| <member>"code"</member> |
| <member>"sup"</member> |
| <member>"var"</member> |
| <member>"em"</member> |
| </var> |
| <var name="replacedChild" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <getElementsByTagName interface="Element" obj="employeeNode" var="childList" tagname='"*"'/> |
| <item interface="NodeList" obj="childList" index="0" var="newChild"/> |
| <item interface="NodeList" obj="childList" index="5" var="oldChild"/> |
| <replaceChild var="replacedChild" obj="employeeNode" newChild="newChild" oldChild="oldChild"/> |
| <assertSame actual="replacedChild" expected="oldChild" id="return_value_same"/> |
| <for-each collection="childList" member="childNode"> |
| <nodeName var="childName" obj="childNode"/> |
| <nodeType var="nodeType" obj="childNode"/> |
| <if><equals actual="nodeType" expected="1"/> |
| <append collection="actual" item="childName"/> |
| <else> |
| <assertEquals actual="nodeType" expected="3" id="textNodeType" ignoreCase="false"/> |
| <assertEquals actual="childName" expected='"#text"' id="textNodeName" ignoreCase="false"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="actual" expected="expected" id="childNames" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodereplacechildnodeancestor.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodereplacechildnodeancestor"> |
| <metadata> |
| <title>hc_nodeReplaceChildNodeAncestor</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if the node to put |
| in is one of this node's ancestors. |
| Retrieve the second employee and attempt to replace |
| one of its children with an ancestor node(root node). |
| An attempt to make such a replacement should raise the |
| desired exception. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="replacedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement obj="doc" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="0" var="oldChild"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <replaceChild var="replacedNode" obj="employeeNode" newChild="newChild" oldChild="oldChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodereplacechildnodename.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodereplacechildnodename"> |
| <metadata> |
| <title>hc_nodeReplaceChildNodeName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method returns |
| the node being replaced. |
| Replace the second Element of the second employee with |
| a newly created node Element and check the NodeName |
| returned by the "replaceChild(newChild,oldChild)" |
| method. The returned node should have a NodeName equal |
| to "em". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="replacedNode" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <getElementsByTagName obj="employeeNode" var="childList" interface="Element" tagname='"em"'/> |
| <item interface="NodeList" obj="childList" index="0" var="oldChild"/> |
| <createElement obj="doc" tagName='"br"' var="newChild"/> |
| <replaceChild obj="employeeNode" newChild="newChild" oldChild="oldChild" var="replacedNode"/> |
| <nodeName obj="replacedNode" var="childName"/> |
| <assertEquals actual="childName" expected='"em"' id="replacedNodeName" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodereplacechildoldchildnonexistent.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodereplacechildoldchildnonexistent"> |
| <metadata> |
| <title>hc_nodeReplaceChildOldChildNonexistent</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method raises a |
| NOT_FOUND_ERR DOMException if the old child is |
| not a child of this node. |
| Retrieve the second employee and attempt to replace a |
| node that is not one of its children. An attempt to |
| replace such a node should raise the desired exception. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=247"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="oldChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="replacedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElement obj="doc" tagName='"br"' var="newChild"/> |
| <createElement obj="doc" tagName='"b"' var="oldChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"p"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <replaceChild var="replacedNode" obj="elementNode" newChild="newChild" oldChild="oldChild"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodetextnodeattribute.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodetextnodeattribute"> |
| <metadata> |
| <title>hc_nodeTextNodeAttribute</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getAttributes()" method invoked on a Text |
| Node returns null. |
| Retrieve the Text node from the last child of the |
| first employee and invoke the "getAttributes()" method |
| on the Text Node. It should return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- Text interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1312295772"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <firstChild interface="Node" obj="testAddr" var="textNode"/> |
| <attributes obj="textNode" var="attrList"/> |
| <assertNull actual="attrList" id="text_attributes_is_null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodetextnodename.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodetextnodename"> |
| <metadata> |
| <title>hc_nodeTextNodeName</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| Text Node is "#text". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="textNode" type="Node"/> |
| <var name="textName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <firstChild interface="Node" obj="testAddr" var="textNode"/> |
| <nodeName obj="textNode" var="textName"/> |
| <assertEquals actual="textName" expected='"#text"' id="textNodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodetextnodetype.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodetextnodetype"> |
| <metadata> |
| <title>hc_nodeTextNodeType</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getNodeType()" method for a Text Node |
| returns the constant value 3. |
| Retrieve the Text node from the last child of |
| the first employee and invoke the "getNodeType()" |
| method. The method should return 3. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="textNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <firstChild interface="Node" obj="testAddr" var="textNode"/> |
| <nodeType obj="textNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="3" id="nodeTextNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodetextnodevalue.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodetextnodevalue"> |
| <metadata> |
| <title>hc_nodeTextNodeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| Text Node is the content of the Text node. |
| Retrieve the Text node from the last child of the first |
| employee and check the string returned by the |
| "getNodeValue()" method. It should be equal to |
| "1230 North Ave. Dallas, Texas 98551". |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="textNode" type="Node"/> |
| <var name="textValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <firstChild interface="Node" obj="testAddr" var="textNode"/> |
| <nodeValue obj="textNode" var="textValue"/> |
| <assertEquals actual="textValue" expected='"1230 North Ave. Dallas, Texas 98551"' |
| id="textNodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodevalue01.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodevalue01"> |
| <metadata> |
| <title>hc_nodevalue01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An element is created, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Element"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElement obj="doc" var="newNode" tagName='"acronym"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodevalue02.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodevalue02"> |
| <metadata> |
| <title>hc_nodevalue02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An comment is created, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1728279322"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createComment obj="doc" var="newNode" data='"This is a new Comment node"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertEquals actual="newValue" expected='"This is a new Comment node"' ignoreCase="false" id="initial"/> |
| <!-- attempt to change the value --> |
| <nodeValue obj="newNode" value='"This should have an effect"'/> |
| <!-- retrieve the value --> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertEquals actual="newValue" expected='"This should have an effect"' id="afterChange" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodevalue03.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodevalue03"> |
| <metadata> |
| <title>hc_nodevalue03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An entity reference is created, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-11C98490"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <if><contentType type="text/html"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createEntityReference obj="doc" var="newNode" name='"ent1"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <else> |
| <createEntityReference obj="doc" var="newNode" name='"ent1"'/> |
| <assertNotNull actual="newNode" id="createdEntRefNotNull"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodevalue04.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodevalue04"> |
| <metadata> |
| <title>hc_nodevalue04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An document type accessed, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A31"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype obj="doc" var="newNode"/> |
| <assertTrue id="docTypeNotNullOrDocIsHTML"> |
| <or> |
| <notNull obj="newNode"/> |
| <contentType type="text/html"/> |
| </or> |
| </assertTrue> |
| <if><notNull obj="newNode"/> |
| <assertNotNull actual="newNode" id="docTypeNotNull"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodevalue05.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodevalue05"> |
| <metadata> |
| <title>hc_nodevalue05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| A document fragment is created, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A3"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="newNode"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodevalue06.xml |
|---|
| 0,0 → 1,35 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodevalue06"> |
| <metadata> |
| <title>hc_nodevalue06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An document is accessed, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| </metadata> |
| <var name="newNode" type="Document"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="newNode" href="hc_staff" willBeModified="true"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodevalue07.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodevalue07"> |
| <metadata> |
| <title>hc_nodevalue07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An Entity is accessed, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-527DCFF2"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <var name="nodeMap" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype obj="doc" var="docType"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="nodeMap"/> |
| <assertNotNull actual="nodeMap" id="entitiesNotNull"/> |
| <getNamedItem obj="nodeMap" name='"alpha"' var="newNode"/> |
| <assertNotNull actual="newNode" id="entityNotNull"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_nodevalue08.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_nodevalue08"> |
| <metadata> |
| <title>hc_nodevalue08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An notation is accessed, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-5431D1B9"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <var name="nodeMap" type="NamedNodeMap"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype obj="doc" var="docType"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="nodeMap"/> |
| <assertNotNull actual="nodeMap" id="notationsNotNull"/> |
| <getNamedItem obj="nodeMap" name='"notation1"' var="newNode"/> |
| <assertNotNull actual="newNode" id="notationNotNull"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_notationsremovenameditem1.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_notationsremovenameditem1"> |
| <metadata> |
| <title>hc_notationsremovenameditem1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An attempt to add remove an notation should result in a NO_MODIFICATION_ERR. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <!-- DocumentType.notations --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D46829EF"/> |
| <!-- NamedNodeMap.removeNamedItem --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D58B193"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations var="notations" obj="docType"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeNamedItem var="retval" obj="notations" name='"notation1"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_notationssetnameditem1.xml.notimpl |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_notationssetnameditem1"> |
| <metadata> |
| <title>hc_notationssetnameditem1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An attempt to add an element to the named node map returned by notations should |
| result in a NO_MODIFICATION_ERR or HIERARCHY_REQUEST_ERR. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <!-- DocumentType.notations --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D46829EF"/> |
| <!-- NamedNodeMap.setNamedItem --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="retval" type="Node"/> |
| <var name="elem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations var="notations" obj="docType"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <createElement var="elem" obj="doc" tagName='"br"'/> |
| <try> |
| <setNamedItem var="retval" obj="notations" arg="elem"/> |
| <fail id="throw_HIER_OR_NO_MOD_ERR"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| </catch> |
| </try> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_textindexsizeerrnegativeoffset.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_textindexsizeerrnegativeoffset"> |
| <metadata> |
| <title>hc_textIndexSizeErrNegativeOffset</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "splitText(offset)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset is |
| negative. |
| Retrieve the textual data from the second child of the |
| third employee and invoke the "splitText(offset)" method. |
| The desired exception should be raised since the offset |
| is a negative number. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-38853C1D')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"strong"'/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="textNode"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <splitText obj="textNode" var="splitNode" offset="-69"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_textindexsizeerroffsetoutofbounds.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_textindexsizeerroffsetoutofbounds"> |
| <metadata> |
| <title>hc_textIndexSizeErrOffsetOutOfBounds</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "splitText(offset)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset is |
| greater than the number of characters in the Text node. |
| Retrieve the textual data from the second child of the |
| third employee and invoke the "splitText(offset)" method. |
| The desired exception should be raised since the offset |
| is a greater than the number of characters in the Text |
| node. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-38853C1D')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"strong"'/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="textNode"/> |
| <assertDOMException id="throw_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <splitText obj="textNode" var="splitNode" offset="300"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_textparseintolistofelements.xml.int-broken |
|---|
| 0,0 → 1,75 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_textparseintolistofelements"> |
| <metadata> |
| <title>hc_textParseIntoListOfElements</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Retrieve the textual data from the last child of the |
| second employee. That node is composed of two |
| EntityReference nodes and two Text nodes. After |
| the content node is parsed, the "acronym" Element |
| should contain four children with each one of the |
| EntityReferences containing one child. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <!--childNodes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-11C98490"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-745549614"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="addressNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <var name="grandChild" type="Node"/> |
| <var name="length" type="int"/> |
| <var name="result" type="List"/> |
| <var name="expectedNormal" type="List"> |
| <member>"β"</member> |
| <member>" Dallas, "</member> |
| <member>"γ"</member> |
| <member>"\n 98554"</member> |
| </var> |
| <var name="expectedExpanded" type="List"> |
| <member>"β Dallas, γ\n 98554"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="addressNode" index="1"/> |
| <childNodes obj="addressNode" var="childList"/> |
| <length var="length" obj="childList" interface="NodeList"/> |
| <for-each collection="childList" member="child"> |
| <nodeValue obj="child" var="value"/> |
| <if> |
| <isNull obj="value"/> |
| <firstChild interface="Node" obj="child" var="grandChild"/> |
| <assertNotNull actual="grandChild" id="grandChildNotNull"/> |
| <nodeValue obj="grandChild" var="value"/> |
| <append collection="result" item="value"/> |
| <else> |
| <append collection="result" item="value"/> |
| </else> |
| </if> |
| </for-each> |
| <if><equals actual="length" expected="1" ignoreCase="false"/> |
| <assertEquals actual="result" expected="expectedExpanded" ignoreCase="false" id="assertEqCoalescing"/> |
| <else> |
| <assertEquals actual="result" expected="expectedNormal" ignoreCase="false" id="assertEqNormal"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_textsplittextfour.xml.kfail |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_textsplittextfour"> |
| <metadata> |
| <title>hc_textSplitTextFour</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "splitText(offset)" method returns the new Text node. |
| Retrieve the textual data from the last child of the |
| first employee and invoke the "splitText(offset)" method. |
| The method should return the new Text node. The offset |
| value used for this test is 30. The "getNodeValue()" |
| method is called to check that the new node now contains |
| the characters at and after position 30. |
| (Starting count at 0) |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="addressNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"acronym"'/> |
| <item interface="NodeList" obj="elementList" var="addressNode" index="0"/> |
| <firstChild interface="Node" obj="addressNode" var="textNode"/> |
| <splitText obj="textNode" var="splitNode" offset="30"/> |
| <nodeValue obj="splitNode" var="value"/> |
| <assertEquals actual="value" expected='"98551"' id="textSplitTextFourAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_textsplittextone.xml.kfail |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_textsplittextone"> |
| <metadata> |
| <title>hc_textSplitTextOne</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "splitText(offset)" method breaks the Text node into |
| two Text nodes at the specified offset keeping each node |
| as siblings in the tree. |
| Retrieve the textual data from the second child of the |
| third employee and invoke the "splitText(offset)" method. |
| The method splits the Text node into two new sibling |
| Text nodes keeping both of them in the tree. This test |
| checks the "nextSibling()" method of the original node |
| to ensure that the two nodes are indeed siblings. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <var name="secondPart" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"strong"'/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="textNode"/> |
| <splitText obj="textNode" var="splitNode" offset="7"/> |
| <nextSibling interface="Node" obj="textNode" var="secondPart"/> |
| <nodeValue obj="secondPart" var="value"/> |
| <assertEquals actual="value" expected='"Jones"' id="textSplitTextOneAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_textsplittextthree.xml.kfail |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_textsplittextthree"> |
| <metadata> |
| <title>hc_textSplitTextThree</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| After the "splitText(offset)" method breaks the Text node |
| into two Text nodes, the new Text node contains all the |
| content at and after the offset point. |
| Retrieve the textual data from the second child of the |
| third employee and invoke the "splitText(offset)" method. |
| The new Text node should contain all the content |
| at and after the offset point. The "getNodeValue()" |
| method is called to check that the new node now contains |
| the characters at and after position seven. |
| (Starting count at 0) |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"strong"'/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="textNode"/> |
| <splitText obj="textNode" var="splitNode" offset="6"/> |
| <nodeValue obj="splitNode" var="value"/> |
| <assertEquals actual="value" expected='" Jones"' id="textSplitTextThreeAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_textsplittexttwo.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_textsplittexttwo"> |
| <metadata> |
| <title>hc_textSplitTextTwo</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| After the "splitText(offset)" method breaks the Text node |
| into two Text nodes, the original node contains all the |
| content up to the offset point. |
| Retrieve the textual data from the second child of the |
| third employee and invoke the "splitText(offset)" method. |
| The original Text node should contain all the content |
| up to the offset point. The "getNodeValue()" method |
| is called to check that the original node now contains |
| the first five characters. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"strong"'/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="textNode"/> |
| <splitText obj="textNode" var="splitNode" offset="5"/> |
| <nodeValue obj="textNode" var="value"/> |
| <assertEquals actual="value" expected='"Roger"' id="textSplitTextTwoAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/hc_textwithnomarkup.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hc_textwithnomarkup"> |
| <metadata> |
| <title>hc_textWithNoMarkup</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If there is not any markup inside an Element or Attr node |
| content, then the text is contained in a single object |
| implementing the Text interface that is the only child |
| of the element. |
| Retrieve the textual data from the second child of the |
| third employee. That Text node contains a block of |
| multiple text lines without markup, so they should be |
| treated as a single Text node. The "getNodeValue()" |
| method should contain the combination of the two lines. |
| </description> |
| <date qualifier="created">2002-06-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1312295772"/> |
| <!--nodeValue attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="nodeV" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"strong"'/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="nodeV"/> |
| <nodeValue obj="nodeV" var="value"/> |
| <assertEquals actual="value" expected='"Roger\n Jones"' id="textWithNoMarkupAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/metadata.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE metadata SYSTEM "dom1.dtd"> |
| <metadata xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1"> |
| </metadata> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapchildnoderange.xml.int-broken |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapchildnoderange"> |
| <metadata> |
| <title>namednodemapChildNodeRange</title> |
| <creator>NIST</creator> |
| <description> |
| The range of valid child node indices is 0 to Length -1. |
| Create a NamedNodeMap object from the attributes of the |
| last child of the third employee and traverse the |
| list from index 0 thru length -1. All indices should |
| be valid. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!--item--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| <!--length attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D0FB19E"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="child" type="Node"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="2"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <length var="length" obj="attributes" interface="NamedNodeMap"/> |
| <assertEquals actual="length" expected="2" id="length" ignoreCase="false"/> |
| <item var="child" index="0" obj="attributes" interface="NamedNodeMap"/> |
| <item var="child" index="1" obj="attributes" interface="NamedNodeMap"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapgetnameditem.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapgetnameditem"> |
| <metadata> |
| <title>namednodemapGetNamedItem</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNamedItem(name)" method retrieves a node |
| specified by name. |
| Retrieve the second employee and create a NamedNodeMap |
| listing of the attributes of the last child. Once the |
| list is created an invocation of the "getNamedItem(name)" |
| method is done with name="domestic". This should result |
| in the domestic Attr node being returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1074577549"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="1"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name=""domestic""/> |
| <nodeName obj="domesticAttr" var="attrName"/> |
| <assertEquals actual="attrName" expected=""domestic"" id="namednodemapGetNamedItemAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapinuseattributeerr.xml.kfail |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapinuseattributeerr"> |
| <metadata> |
| <title>namedNodeMapInUseAttributeErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "setNamedItem(arg)" method raises a |
| INUSE_ATTRIBUTE_ERR DOMException if "arg" is an |
| Attr that is already in an attribute of another Element. |
| Create a NamedNodeMap object from the attributes of the |
| last child of the third employee and attempt to add |
| an attribute that is already being used by the first |
| employee. This should raise the desired exception. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1025163788')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="firstNode" type="Element"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="setAttr" type="Attr"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="firstNode" index="0"/> |
| <createAttribute obj="doc" var="domesticAttr" name=""domestic""/> |
| <value interface="Attr" obj="domesticAttr" value=""Yes""/> |
| <setAttributeNode var="setAttr" obj="firstNode" newAttr="domesticAttr"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="2"/> |
| <attributes obj="testNode" var="attributes"/> |
| <assertDOMException id="throw_INUSE_ATTRIBUTE_ERR"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setNamedItem var="setNode" interface="NamedNodeMap" obj="attributes" arg="domesticAttr"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapnotfounderr.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapnotfounderr"> |
| <metadata> |
| <title>namednodemapNotFoundErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeNamedItem(name)" method raises a |
| NOT_FOUND_ERR DOMException if there is not a node |
| named "name" in the map. |
| Create a NamedNodeMap object from the attributes of the |
| last child of the third employee and attempt to remove |
| the "district" attribute. There is not a node named |
| "district" in the list and therefore the desired |
| exception should be raised. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D58B193"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-D58B193')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INUSE_ATTRIBUTE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Element"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="2"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeNamedItem var="removedNode" interface="NamedNodeMap" obj="attributes" name=""district""/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapnumberofnodes.xml.int-broken |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapnumberofnodes"> |
| <metadata> |
| <title>namednodemapNumberOfNodes</title> |
| <creator>NIST</creator> |
| <description> |
| The "getLength()" method returns the number of nodes |
| in the map. |
| Retrieve the second employee and create a NamedNodeMap |
| listing of the attributes of the last child. Once the |
| list is created an invocation of the "getLength()" |
| method is executed. The number of nodes should be 2. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!--length attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6D0FB19E"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="2"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <length var="length" obj="attributes" interface="NamedNodeMap"/> |
| <assertEquals actual="length" expected="2" id="length" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapremovenameditem.xml.kfail |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapremovenameditem"> |
| <metadata> |
| <title>namednodemapRemoveNamedItem</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeNamedItem(name)" method removes a node |
| specified by name. |
| Retrieve the third employee and create a NamedNodeMap |
| object of the attributes of the last child. Once the |
| list is created invoke the "removeNamedItem(name)" |
| method with name="street". This should result |
| in the removal of the specified attribute and |
| the "getSpecified()" method should return false. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D58B193"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="specified" type="boolean"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <assertNotNull actual="attributes" id="attributesNotNull"/> |
| <removeNamedItem var="removedNode" interface="NamedNodeMap" obj="attributes" name=""street""/> |
| <getNamedItem obj="attributes" var="streetAttr" name=""street""/> |
| <assertNotNull actual="streetAttr" id="streetAttrNotNull"/> |
| <specified obj="streetAttr" var="specified"/> |
| <assertFalse actual="specified" id="attrNotSpecified"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapremovenameditemgetvalue.xml.kfail |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapremovenameditemgetvalue"> |
| <metadata> |
| <title>namednodemapRemoveNamedItemGetValue</title> |
| <creator>NIST</creator> |
| <description> |
| If the node removed by the "removeNamedItem(name)" method |
| is an Attr node with a default value it is immediately |
| replaced. |
| Retrieve the third employee and create a NamedNodeMap |
| object of the attributes of the last child. Once the |
| list is created invoke the "removeNamedItem(name)" |
| method with name="street". The "removeNamedItem(name)" |
| method should remove the "street" attribute and since |
| it has a default value of "Yes", that value should |
| immediately be the attributes value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D58B193"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| <!-- DOM WG opinion on default attributes --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Mar/0002.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Attr"/> |
| <var name="value" type="DOMString"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="2"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <assertNotNull actual="attributes" id="attributesNotNull"/> |
| <removeNamedItem var="removedNode" obj="attributes" name=""street""/> |
| <getNamedItem obj="attributes" var="streetAttr" name=""street""/> |
| <assertNotNull actual="streetAttr" id="streetAttrNotNull"/> |
| <value interface="Attr" obj="streetAttr" var="value"/> |
| <assertEquals actual="value" expected=""Yes"" id="namednodemapRemoveNamedItemGetValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapremovenameditemreturnnodevalue.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapremovenameditemreturnnodevalue"> |
| <metadata> |
| <title>namednodemapRemoveNamedItemReturnNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeNamedItem(name)" method returns the node |
| removed from the map. |
| Retrieve the third employee and create a NamedNodeMap |
| object of the attributes of the last child. Once the |
| list is created invoke the "removeNamedItem(name)" |
| method with name="street". The "removeNamedItem(name)" |
| method should remove the existing "street" attribute |
| and return it. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-D58B193"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="removedNode" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <removeNamedItem interface="NamedNodeMap" obj="attributes" var="removedNode" name=""street""/> |
| <nodeValue obj="removedNode" var="value"/> |
| <assertEquals actual="value" expected=""No"" id="namednodemapRemoveNamedItemReturnNodeValueAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapreturnattrnode.xml.kfail |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapreturnattrnode"> |
| <metadata> |
| <title>namednodemapReturnAttrNode</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNamedItem(name)" method returns a node of any |
| type specified by name. |
| Retrieve the second employee and create a NamedNodeMap |
| listing of the attributes of the last child. Once the |
| list is created an invocation of the "getNamedItem(name)" |
| method is done with name="street". This should result |
| in the method returning an Attr node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--getNamedItem--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1074577549"/> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| <!--name attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1112119403"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="streetAttr" type="Node"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="1"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItem obj="attributes" var="streetAttr" name=""street""/> |
| <assertInstanceOf obj="streetAttr" type="Attr" id="typeAssert"/> |
| <nodeName obj="streetAttr" var="attrName"/> |
| <assertEquals actual="attrName" expected=""street"" id="nodeName" ignoreCase="false"/> |
| <name obj="streetAttr" var="attrName" interface="Attr"/> |
| <assertEquals actual="attrName" expected=""street"" id="attrName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapreturnfirstitem.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapreturnfirstitem"> |
| <metadata> |
| <title>namednodemapReturnFirstItem</title> |
| <creator>NIST</creator> |
| <description> |
| The "item(index)" method returns the indexth item in |
| the map(test for first item). |
| Retrieve the second employee and create a NamedNodeMap |
| listing of the attributes of the last child. Since the |
| DOM does not specify an order of these nodes the contents |
| of the FIRST node can contain either "domestic" or "street". |
| The test should return "true" if the FIRST node is either |
| of these values. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="child" type="Node"/> |
| <var name="name" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="1"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <item interface="NamedNodeMap" obj="attributes" var="child" index="0"/> |
| <nodeName obj="child" var="name"/> |
| <assertTrue id="namednodemapReturnFirstItemAssert"> |
| <or> |
| <equals actual="name" expected=""domestic"" ignoreCase="false"/> |
| <equals actual="name" expected=""street"" ignoreCase="false"/> |
| </or> |
| </assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapreturnlastitem.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapreturnlastitem"> |
| <metadata> |
| <title>namednodemapReturnLastItem</title> |
| <creator>NIST</creator> |
| <description> |
| The "item(index)" method returns the indexth item in |
| the map(test for last item). |
| Retrieve the second employee and create a NamedNodeMap |
| listing of the attributes of the last child. Since the |
| DOM does not specify an order of these nodes the contents |
| of the LAST node can contain either "domestic" or "street". |
| The test should return "true" if the LAST node is either |
| of these values. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="child" type="Node"/> |
| <var name="name" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="1"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <item interface="NamedNodeMap" obj="attributes" var="child" index="1"/> |
| <nodeName obj="child" var="name"/> |
| <assertTrue id="namednodemapReturnLastItemAssert"> |
| <or> |
| <equals actual="name" expected=""domestic"" ignoreCase="false"/> |
| <equals actual="name" expected=""street"" ignoreCase="false"/> |
| </or> |
| </assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapreturnnull.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapreturnnull"> |
| <metadata> |
| <title>namednodemapReturnNull</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNamedItem(name)" method returns null of the |
| specified name did not identify any node in the map. |
| Retrieve the second employee and create a NamedNodeMap |
| listing of the attributes of the last child. Once the |
| list is created an invocation of the "getNamedItem(name)" |
| method is done with name="district". This name does not |
| match any names in the list therefore the method should |
| return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--getNamedItem--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1074577549"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="districtNode" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="1"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItem obj="attributes" var="districtNode" name=""district""/> |
| <assertNull actual="districtNode" id="namednodemapReturnNullAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapsetnameditem.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapsetnameditem"> |
| <metadata> |
| <title>namednodemapSetNamedItem</title> |
| <creator>NIST</creator> |
| <description> |
| The "setNamedItem(arg)" method adds a node using its |
| nodeName attribute. |
| Retrieve the second employee and create a NamedNodeMap |
| object from the attributes of the last child by |
| invoking the "getAttributes()" method. Once the |
| list is created an invocation of the "setNamedItem(arg)" |
| method is done with arg=newAttr, where newAttr is a |
| new Attr Node previously created. The "setNamedItem(arg)" |
| method should add then new node to the NamedNodeItem |
| object by using its "nodeName" attribute("district'). |
| This node is then retrieved using the "getNamedItem(name)" |
| method. This test uses the "createAttribute(name)" |
| method from the document interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="districtNode" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="1"/> |
| <createAttribute obj="doc" var="newAttribute" name=""district""/> |
| <attributes obj="testAddress" var="attributes"/> |
| <setNamedItem var="setNode" obj="attributes" arg="newAttribute"/> |
| <getNamedItem obj="attributes" var="districtNode" name=""district""/> |
| <nodeName obj="districtNode" var="attrName"/> |
| <assertEquals actual="attrName" expected=""district"" id="namednodemapSetNamedItemAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapsetnameditemreturnvalue.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapsetnameditemreturnvalue"> |
| <metadata> |
| <title>namednodemapSetNamedItemReturnValue</title> |
| <creator>NIST</creator> |
| <description> |
| If the "setNamedItem(arg)" method replaces an already |
| existing node with the same name then the already |
| existing node is returned. |
| Retrieve the third employee and create a NamedNodeMap |
| object from the attributes of the last child by |
| invoking the "getAttributes()" method. Once the |
| list is created an invocation of the "setNamedItem(arg)" |
| method is done with arg=newAttr, where newAttr is a |
| new Attr Node previously created and whose node name |
| already exists in the map. The "setNamedItem(arg)" |
| method should replace the already existing node with |
| the new one and return the existing node. |
| This test uses the "createAttribute(name)" method from |
| the document interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="newNode" type="Node"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <createAttribute obj="doc" var="newAttribute" name=""street""/> |
| <attributes obj="testAddress" var="attributes"/> |
| <setNamedItem interface="NamedNodeMap" obj="attributes" var="newNode" arg="newAttribute"/> |
| <nodeValue obj="newNode" var="attrValue"/> |
| <assertEquals actual="attrValue" expected=""No"" |
| id="returnedNodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapsetnameditemthatexists.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapsetnameditemthatexists"> |
| <metadata> |
| <title>namednodemapSetNamedItemThatExists</title> |
| <creator>NIST</creator> |
| <description> |
| If the node to be added by the "setNamedItem(arg)" method |
| already exists in the NamedNodeMap, it is replaced by |
| the new one. |
| Retrieve the second employee and create a NamedNodeMap |
| object from the attributes of the last child by |
| invoking the "getAttributes()" method. Once the |
| list is created an invocation of the "setNamedItem(arg)" |
| method is done with arg=newAttr, where newAttr is a |
| new Attr Node previously created and whose node name |
| already exists in the map. The "setNamedItem(arg)" |
| method should replace the already existing node with |
| the new one. |
| This node is then retrieved using the "getNamedItem(name)" |
| method. This test uses the "createAttribute(name)" |
| method from the document interface |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="districtNode" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="1"/> |
| <createAttribute obj="doc" var="newAttribute" name=""street""/> |
| <attributes obj="testAddress" var="attributes"/> |
| <setNamedItem var="setNode" obj="attributes" arg="newAttribute"/> |
| <getNamedItem obj="attributes" var="districtNode" name=""street""/> |
| <nodeValue obj="districtNode" var="attrValue"/> |
| <assertEquals actual="attrValue" expected="""" |
| id="streetValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapsetnameditemwithnewvalue.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapsetnameditemwithnewvalue"> |
| <metadata> |
| <title>namednodemapSetNamedItemWithNewValue</title> |
| <creator>NIST</creator> |
| <description> |
| If the "setNamedItem(arg)" method does not replace an |
| existing node with the same name then it returns null. |
| Retrieve the third employee and create a NamedNodeMap |
| object from the attributes of the last child. |
| Once the list is created the "setNamedItem(arg)" method |
| is invoked with arg=newAttr, where newAttr is a |
| newly created Attr Node and whose node name |
| already exists in the map. The "setNamedItem(arg)" |
| method should add the new node and return null. |
| This test uses the "createAttribute(name)" method from |
| the document interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-349467F9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="newNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <createAttribute obj="doc" var="newAttribute" name=""district""/> |
| <attributes obj="testAddress" var="attributes"/> |
| <setNamedItem interface="NamedNodeMap" obj="attributes" var="newNode" arg="newAttribute"/> |
| <assertNull actual="newNode" id="returnedNodeNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/namednodemapwrongdocumenterr.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="namednodemapwrongdocumenterr"> |
| <metadata> |
| <title>namednodemapWrongDocumentErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "setNamedItem(arg)" method raises a |
| WRONG_DOCUMENT_ERR DOMException if "arg" was created |
| from a different document than the one that created |
| the NamedNodeMap. |
| Create a NamedNodeMap object from the attributes of the |
| last child of the third employee and attempt to add |
| another Attr node to it that was created from a |
| different DOM document. This should raise the desired |
| exception. This method uses the "createAttribute(name)" |
| method from the Document interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1025163788')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="newAttribute" type="Node"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc1" href="staff" willBeModified="true"/> |
| <load var="doc2" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc1" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <createAttribute obj="doc2" var="newAttribute" name=""newAttribute""/> |
| <attributes obj="testAddress" var="attributes"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <setNamedItem var="setNode" obj="attributes" arg="newAttribute"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeappendchild.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeappendchild"> |
| <metadata> |
| <title>nodeAppendChild</title> |
| <creator>NIST</creator> |
| <description> |
| The "appendChild(newChild)" method adds the node |
| "newChild" to the end of the list of children of the |
| node. |
| Retrieve the second employee and append a new Element |
| node to the list of children. The last node in the list |
| is then retrieved and its NodeName examined. The |
| "getNodeName()" method should return "newChild". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="createdNode" type="Node"/> |
| <var name="lchild" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <createElement obj="doc" tagName=""newChild"" var="createdNode"/> |
| <appendChild var="appendedChild" obj="employeeNode" newChild="createdNode"/> |
| <lastChild interface="Node" obj="employeeNode" var="lchild"/> |
| <nodeName obj="lchild" var="childName"/> |
| <assertEquals actual="childName" expected=""newChild"" id="nodeAppendChildAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeappendchildchildexists.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeappendchildchildexists"> |
| <metadata> |
| <title>nodeAppendChildChildExists</title> |
| <creator>NIST</creator> |
| <description> |
| If the "newChild" is already in the tree, it is first |
| removed before the new one is appended. |
| Retrieve the first child of the second employee and |
| append the first child to the end of the list. After |
| the "appendChild(newChild)" method is invoked the first |
| child should be the one that was second and the last |
| child should be the one that was first. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="childNode" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="lchild" type="Node"/> |
| <var name="fchild" type="Node"/> |
| <var name="lchildName" type="DOMString"/> |
| <var name="fchildName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="initialName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="childNode"/> |
| <firstChild interface="Node" obj="childNode" var="newChild"/> |
| <nodeName var="initialName" obj="newChild"/> |
| <appendChild var="appendedChild" obj="childNode" newChild="newChild"/> |
| <firstChild interface="Node" obj="childNode" var="fchild"/> |
| <nodeName obj="fchild" var="fchildName"/> |
| <lastChild interface="Node" obj="childNode" var="lchild"/> |
| <nodeName obj="lchild" var="lchildName"/> |
| <if><equals actual="initialName" expected='"employeeId"' ignoreCase="false"/> |
| <assertEquals id="assert1_nowhitespace" actual="fchildName" expected='"name"' ignoreCase="false"/> |
| <assertEquals id="assert2_nowhitespace" actual="lchildName" expected='"employeeId"' ignoreCase="false"/> |
| <else> |
| <assertEquals id="assert1" actual="fchildName" expected='"employeeId"' ignoreCase="false"/> |
| <assertEquals id="assert2" actual="lchildName" expected='"#text"' ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeappendchilddocfragment.xml |
|---|
| 0,0 → 1,70 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeappendchilddocfragment"> |
| <metadata> |
| <title>nodeAppendChildDocFragment</title> |
| <creator>NIST</creator> |
| <description> |
| Create and populate a new DocumentFragment object and |
| append it to the second employee. After the |
| "appendChild(newChild)" method is invoked retrieve the |
| new nodes at the end of the list, they should be the |
| two Element nodes from the DocumentFragment. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="newdocFragment" type="DocumentFragment"/> |
| <var name="newChild1" type="Node"/> |
| <var name="newChild2" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="nodeType" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="expected" type="List"> |
| <member>"employeeId"</member> |
| <member>"name"</member> |
| <member>"position"</member> |
| <member>"salary"</member> |
| <member>"gender"</member> |
| <member>"address"</member> |
| <member>"newChild1"</member> |
| <member>"newChild2"</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" |
| tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <createDocumentFragment obj="doc" var="newdocFragment"/> |
| <createElement obj="doc" tagName=""newChild1"" var="newChild1"/> |
| <createElement obj="doc" tagName=""newChild2"" var="newChild2"/> |
| <appendChild var="appendedChild" obj="newdocFragment" newChild="newChild1"/> |
| <appendChild var="appendedChild" obj="newdocFragment" newChild="newChild2"/> |
| <appendChild var="appendedChild" obj="employeeNode" newChild="newdocFragment"/> |
| <for-each collection="childList" member="child"> |
| <nodeType var="nodeType" obj="child"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <nodeName var="childName" obj="child"/> |
| <append collection="result" item="childName"/> |
| </if> |
| </for-each> |
| <assertEquals actual="result" expected="expected" ignoreCase="false" id="elementNames"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeappendchildgetnodename.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeappendchildgetnodename"> |
| <metadata> |
| <title>nodeAppendChildGetNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The "appendChild(newChild)" method returns the node |
| added. |
| Append a newly created node to the child list of the |
| second employee and check the NodeName returned. The |
| "getNodeName()" method should return "newChild". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="newChild" type="Node"/> |
| <var name="appendNode" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <createElement obj="doc" tagName=""newChild"" var="newChild"/> |
| <appendChild obj="employeeNode" newChild="newChild" var="appendNode"/> |
| <nodeName obj="appendNode" var="childName"/> |
| <assertEquals actual="childName" expected=""newChild"" id="nodeAppendChildGetNodeNameAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeappendchildinvalidnodetype.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeappendchildinvalidnodetype"> |
| <metadata> |
| <title>nodeAppendChildInvalidNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "appendChild(newChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if this node is of |
| a type that does not allow children of the type "newChild" |
| to be inserted. |
| Retrieve the root node and attempt to append a newly |
| created Attr node. An Element node cannot have children |
| of the "Attr" type, therefore the desired exception |
| should be raised. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-184E7107')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Element"/> |
| <var name="newChild" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <createAttribute obj="doc" name=""newAttribute"" var="newChild"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <appendChild var="appendedChild" obj="rootNode" newChild="newChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeappendchildnewchilddiffdocument.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeappendchildnewchilddiffdocument"> |
| <metadata> |
| <title>nodeAppendChildNewChildDiffDocument</title> |
| <creator>NIST</creator> |
| <description> |
| The "appendChild(newChild)" method raises a |
| WRONG_DOCUMENT_ERR DOMException if the "newChild" was |
| created from a different document than the one that |
| created this node. |
| Retrieve the second employee and attempt to append |
| a node created from a different document. An attempt |
| to make such a replacement should raise the desired |
| exception. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-184E7107')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc1" href="staff" willBeModified="false"/> |
| <load var="doc2" href="staff" willBeModified="true"/> |
| <createElement obj="doc1" tagName=""newChild"" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc2" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <appendChild var="appendedChild" obj="elementNode" newChild="newChild"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeappendchildnodeancestor.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeappendchildnodeancestor"> |
| <metadata> |
| <title>nodeAppendChildNodeAncestor</title> |
| <creator>NIST</creator> |
| <description> |
| The "appendChild(newChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if the node to |
| append is one of this node's ancestors. |
| Retrieve the second employee and attempt to append |
| an ancestor node(root node) to it. |
| An attempt to make such an addition should raise the |
| desired exception. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-184E7107')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <documentElement obj="doc" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <appendChild var="appendedChild" obj="employeeNode" newChild="newChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeappendchildnomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeappendchildnomodificationallowederr"> |
| <metadata> |
| <title>nodeAppendChildNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "appendChild(newChild)" method causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the FIRST item |
| from the entity reference and execute the "appendChild(newChild)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-184E7107')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entRef" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="createdNode" type="Node"/> |
| <var name="appendedNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item obj="genderList" index="2" var="genderNode" interface="NodeList"/> |
| <firstChild interface="Node" var="entRef" obj="genderNode"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <nodeType var="nodeType" obj="entRef"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <createElement obj="doc" tagName='"text3"' var="createdNode"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <appendChild var="appendedNode" obj="entElement" newChild="createdNode"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeappendchildnomodificationallowederrEE.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeappendchildnomodificationallowederrEE"> |
| <metadata> |
| <title>nodeAppendChildNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "appendChild(newChild)" method causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Create an ent4 entity reference and the "appendChild(newChild)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-21</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-184E7107')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/nodeappendchildnomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="Node"/> |
| <var name="createdNode" type="Node"/> |
| <var name="appendedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <createElement obj="doc" tagName=""text3"" var="createdNode"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <appendChild var="appendedNode" obj="entRef" newChild="createdNode"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeattributenodeattribute.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeattributenodeattribute"> |
| <metadata> |
| <title>characterdataDeleteDataEnd</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method invoked on an Attribute |
| Node returns null. |
| Retrieve the first attribute from the last child of the |
| first employee and invoke the "getAttributes()" method |
| on the Attribute Node. It should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- Attr interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-637646024"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="NamedNodeMap"/> |
| <var name="attrNode" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <attributes obj="testAddr" var="addrAttr"/> |
| <item interface="NamedNodeMap" obj="addrAttr" var="attrNode" index="0"/> |
| <attributes obj="attrNode" var="attrList"/> |
| <assertNull actual="attrList" id="nodeAttributeNodeAttributeAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeattributenodename.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeattributenodename"> |
| <metadata> |
| <title>nodeAttributeNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeName()" method for an |
| Attribute Node is the name of the Attribute. |
| Retrieve the Attribute named "domestic" from the last |
| child of the first employee and check the string returned |
| by the "getNodeName()" method. It should be equal to |
| "domestic". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <getAttributeNode obj="testAddr" name=""domestic"" var="addrAttr"/> |
| <nodeName obj="addrAttr" var="attrName"/> |
| <assertEquals actual="attrName" expected=""domestic"" id="nodeAttributeNodeNameAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeattributenodetype.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeattributenodetype"> |
| <metadata> |
| <title>nodeAttributeNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for an Attribute Node |
| returns the constant value 2. |
| Retrieve the first attribute from the last child of |
| the first employee and invoke the "getNodeType()" |
| method. The method should return 2. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <getAttributeNode obj="testAddr" name=""domestic"" var="addrAttr"/> |
| <nodeType obj="addrAttr" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="2" id="nodeAttrNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeattributenodevalue.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeattributenodevalue"> |
| <metadata> |
| <title>nodeAttributeNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for an |
| Attribute Node is the value of the Attribute. |
| Retrieve the Attribute named "domestic" from the last |
| child of the first employee and check the string returned |
| by the "getNodeValue()" method. It should be equal to |
| "Yes". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <getAttributeNode obj="testAddr" name=""domestic"" var="addrAttr"/> |
| <nodeValue obj="addrAttr" var="attrValue"/> |
| <assertEquals actual="attrValue" expected=""Yes"" id="nodeAttributeNodeValueAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodecdatasectionnodeattribute.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodecdatasectionnodeattribute"> |
| <metadata> |
| <title>nodeCDATASectionNodeAttribute</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method invoked on a CDATASection |
| Node returns null. |
| Retrieve the CDATASection node contained inside the |
| second child of the second employee and invoke the |
| "getAttributes()" method on the CDATASection node. |
| It should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- CDATASection interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-667469212"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="cdataName" type="Element"/> |
| <var name="cdataNode" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""name""/> |
| <item interface="NodeList" obj="elementList" index="1" var="cdataName"/> |
| <lastChild interface="Node" obj="cdataName" var="cdataNode"/> |
| <nodeType var="nodeType" obj="cdataNode"/> |
| <if><notEquals actual="nodeType" expected="4" ignoreCase="false"/> |
| <createCDATASection var="cdataNode" obj="doc" data='""'/> |
| </if> |
| <attributes obj="cdataNode" var="attrList"/> |
| <assertNull actual="attrList" id="cdataSection"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodecdatasectionnodename.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodecdatasectionnodename"> |
| <metadata> |
| <title>nodeCDATASectionNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| CDATASection Node is #cdata-section". |
| Retrieve the CDATASection node inside the second child |
| of the second employee and check the string returned |
| by the "getNodeName()" method. It should be equal to |
| "#cdata-section". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-667469212"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="cdataName" type="Element"/> |
| <var name="cdataNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="cdataNodeName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""name""/> |
| <item interface="NodeList" obj="elementList" index="1" var="cdataName"/> |
| <lastChild interface="Node" obj="cdataName" var="cdataNode"/> |
| <nodeType var="nodeType" obj="cdataNode"/> |
| <if><notEquals actual="nodeType" expected="4" ignoreCase="false"/> |
| <createCDATASection var="cdataNode" obj="doc" data='""'/> |
| </if> |
| <nodeName obj="cdataNode" var="cdataNodeName"/> |
| <assertEquals actual="cdataNodeName" expected='"#cdata-section"' id="cdataNodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodecdatasectionnodetype.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodecdatasectionnodetype"> |
| <metadata> |
| <title>nodeCDATASectionNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for a CDATASection Node |
| returns the constant value 4. |
| Retrieve the CDATASection node contained inside the |
| second child of the second employee and invoke the |
| "getNodeType()" method. The method should return 4. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-667469212"/> |
| </metadata> |
| <implementationAttribute name="coalescing" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testName" type="Element"/> |
| <var name="cdataNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"name"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="testName"/> |
| <lastChild interface="Node" obj="testName" var="cdataNode"/> |
| <nodeType obj="cdataNode" var="nodeType"/> |
| <if><equals actual="nodeType" expected="3" ignoreCase="false"/> |
| <createCDATASection var="cdataNode" obj="doc" data='""'/> |
| <nodeType obj="cdataNode" var="nodeType"/> |
| </if> |
| <assertEquals actual="nodeType" expected="4" id="nodeTypeCDATA" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodecdatasectionnodevalue.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodecdatasectionnodevalue"> |
| <metadata> |
| <title>nodeCDATASectionNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| CDATASection Node is the content of the CDATASection. |
| Retrieve the CDATASection node inside the second child |
| of the second employee and check the string returned |
| by the "getNodeValue()" method. It should be equal to |
| "This is a CDATA Section with EntityReference number 2 |
| &ent2;". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-667469212"/> |
| </metadata> |
| <implementationAttribute name="coalescing" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="cdataName" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="cdataNodeValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""name""/> |
| <item interface="NodeList" obj="elementList" index="1" var="cdataName"/> |
| <childNodes obj="cdataName" var="childList"/> |
| <item interface="NodeList" obj="childList" index="1" var="child"/> |
| <!-- if coalescing, create a CDATASection --> |
| <if><isNull obj="child"/> |
| <createCDATASection var="child" obj="doc" data='"This is a CDATASection with EntityReference number 2 &ent2;"'/> |
| </if> |
| <nodeValue obj="child" var="cdataNodeValue"/> |
| <assertEquals actual="cdataNodeValue" expected='"This is a CDATASection with EntityReference number 2 &ent2;"' id="value" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodechildnodes.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodechildnodes"> |
| <metadata> |
| <title>nodechildnodes</title> |
| <creator>NIST</creator> |
| <description> |
| Collect the element names from Node.childNodes and check against expectations. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childNodes" type="NodeList"/> |
| <var name="childNode" type="Node"/> |
| <var name="childType" type="int"/> |
| <var name="childName" type="DOMString"/> |
| <var name="elementNames" type="List"/> |
| <var name="expectedElementNames" type="List"> |
| <member>"employeeId"</member> |
| <member>"name"</member> |
| <member>"position"</member> |
| <member>"salary"</member> |
| <member>"gender"</member> |
| <member>"address"</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childNodes"/> |
| <for-each collection="childNodes" member="childNode"> |
| <nodeType var="childType" obj="childNode"/> |
| <if><equals actual="childType" expected="1" ignoreCase="false"/> |
| <nodeName var="childName" obj="childNode"/> |
| <append collection="elementNames" item="childName"/> |
| </if> |
| </for-each> |
| <assertEquals actual="elementNames" expected="expectedElementNames" id="elementNames" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodechildnodesappendchild.xml.int-broken |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodechildnodesappendchild"> |
| <metadata> |
| <title>nodechildnodesappendchild</title> |
| <creator>NIST</creator> |
| <description> |
| Add an element and check that the previously retrieved childNodes NodeList |
| is live. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="createdNode" type="Node"/> |
| <var name="expectedLength" type="int"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <length var="expectedLength" obj="childList" interface="NodeList"/> |
| <increment var="expectedLength" value="1"/> |
| <createElement obj="doc" var="createdNode" tagName='"text3"'/> |
| <appendChild obj="employeeNode" newChild="createdNode" var="employeeNode"/> |
| <length var="length" obj="childList" interface="NodeList"/> |
| <assertEquals actual="length" expected="expectedLength" ignoreCase="false" id="childNodeLength"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodechildnodesempty.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodechildnodesempty"> |
| <metadata> |
| <title>nodeChildNodesEmpty</title> |
| <creator>NIST</creator> |
| <description> |
| The "getChildNodes()" method returns a NodeList |
| that contains all children of this node. If there |
| are not any children, this is a NodeList that does not |
| contain any nodes. |
| Retrieve the Text node from the second child of the second |
| employee and invoke the "getChildNodes()" method. The |
| NodeList returned should not have any nodes. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="secondCNode" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="childNodesList" type="NodeList"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="1" var="secondCNode"/> |
| <firstChild interface="Node" obj="secondCNode" var="textNode"/> |
| <childNodes obj="textNode" var="childNodesList"/> |
| <assertSize collection="childNodesList" size="0" id="nodeChildNodesEmptyAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodecloneattributescopied.xml.kfail |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodecloneattributescopied"> |
| <metadata> |
| <title>nodeCloneAttributesCopied</title> |
| <creator>NIST</creator> |
| <description> |
| If the cloneNode method is used to clone an |
| Element node, all the attributes of the Element are |
| copied along with their values. |
| Retrieve the last child of the second employee and invoke |
| the cloneNode method. The |
| duplicate node returned by the method should copy the |
| attributes associated with this node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="addressNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="attributeNode" type="Node"/> |
| <var name="attributeName" type="DOMString"/> |
| <var name="result" type="Collection"/> |
| <var name="expectedResult" type="Collection"> |
| <member>"domestic"</member> |
| <member>"street"</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="addressNode"/> |
| <cloneNode obj="addressNode" deep="false" var="clonedNode"/> |
| <attributes obj="clonedNode" var="attributes"/> |
| <for-each collection="attributes" member="attributeNode"> |
| <nodeName obj="attributeNode" var="attributeName"/> |
| <append collection="result" item="attributeName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedResult" id="nodeCloneAttributesCopiedAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeclonefalsenocopytext.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeclonefalsenocopytext"> |
| <metadata> |
| <title>nodeCloneFalseNoCopyText</title> |
| <creator>NIST</creator> |
| <description> |
| The "cloneNode(deep)" method does not copy text unless it |
| is deep cloned.(Test for deep=false) |
| Retrieve the fourth child of the second employee and |
| the "cloneNode(deep)" method with deep=false. The |
| duplicate node returned by the method should not copy |
| any text data contained in this node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="childNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="lastChildNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="3" var="childNode"/> |
| <cloneNode obj="childNode" deep="false" var="clonedNode"/> |
| <lastChild interface="Node" obj="clonedNode" var="lastChildNode"/> |
| <assertNull actual="lastChildNode" id="noTextNodes"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeclonegetparentnull.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeclonegetparentnull"> |
| <metadata> |
| <title>nodeCloneGetParentNull</title> |
| <creator>NIST</creator> |
| <description> |
| The duplicate node returned by the "cloneNode(deep)" |
| method does not have a ParentNode. |
| Retrieve the second employee and invoke the |
| "cloneNode(deep)" method with deep=false. The |
| duplicate node returned should return null when the |
| "getParentNode()" is invoked. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="parentNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <cloneNode obj="employeeNode" deep="false" var="clonedNode"/> |
| <parentNode interface="Node" obj="clonedNode" var="parentNode"/> |
| <assertNull actual="parentNode" id="nodeCloneGetParentNullAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeclonenodefalse.xml.int-broken |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeclonenodefalse"> |
| <metadata> |
| <title>nodeCloneNodeFalse</title> |
| <creator>NIST</creator> |
| <description> |
| The "cloneNode(deep)" method returns a copy of the node |
| only if deep=false. |
| Retrieve the second employee and invoke the |
| "cloneNode(deep)" method with deep=false. The |
| method should only clone this node. The NodeName and |
| length of the NodeList are checked. The "getNodeName()" |
| method should return "employee" and the "getLength()" |
| method should return 0. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="cloneName" type="DOMString"/> |
| <var name="cloneChildren" type="NodeList"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <cloneNode obj="employeeNode" deep="false" var="clonedNode"/> |
| <nodeName obj="clonedNode" var="cloneName"/> |
| <assertEquals actual="cloneName" expected=""employee"" ignoreCase="false" id="name"/> |
| <childNodes obj="clonedNode" var="cloneChildren"/> |
| <length interface="NodeList" obj="cloneChildren" var="length"/> |
| <assertEquals actual="length" expected="0" ignoreCase="false" id="length"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeclonenodetrue.xml.int-broken |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeclonenodetrue"> |
| <metadata> |
| <title>nodeCloneNodeTrue</title> |
| <creator>NIST</creator> |
| <description> |
| The "cloneNode(deep)" method returns a copy of the node |
| and the subtree under it if deep=true. |
| Retrieve the second employee and invoke the |
| "cloneNode(deep)" method with deep=true. The |
| method should clone this node and the subtree under it. |
| The NodeName of each child in the returned node is |
| checked to insure the entire subtree under the second |
| employee was cloned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="clonedList" type="NodeList"/> |
| <var name="clonedChild" type="Node"/> |
| <var name="clonedChildName" type="DOMString"/> |
| <var name="length" type="int"/> |
| <var name="result" type="List"/> |
| <var name="expectedWhitespace" type="List"> |
| <member>"#text"</member> |
| <member>"employeeId"</member> |
| <member>"#text"</member> |
| <member>"name"</member> |
| <member>"#text"</member> |
| <member>"position"</member> |
| <member>"#text"</member> |
| <member>"salary"</member> |
| <member>"#text"</member> |
| <member>"gender"</member> |
| <member>"#text"</member> |
| <member>"address"</member> |
| <member>"#text"</member> |
| </var> |
| <var name="expectedNoWhitespace" type="List"> |
| <member>"employeeId"</member> |
| <member>"name"</member> |
| <member>"position"</member> |
| <member>"salary"</member> |
| <member>"gender"</member> |
| <member>"address"</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes var="childList" obj="employeeNode"/> |
| <length var="length" obj="childList" interface="NodeList"/> |
| <cloneNode obj="employeeNode" deep="true" var="clonedNode"/> |
| <childNodes obj="clonedNode" var="clonedList"/> |
| <for-each collection="clonedList" member="clonedChild"> |
| <nodeName obj="clonedChild" var="clonedChildName"/> |
| <append collection="result" item="clonedChildName"/> |
| </for-each> |
| <if><equals actual="length" expected="6" ignoreCase="false"/> |
| <assertEquals actual="result" expected="expectedNoWhitespace" id="nowhitespace" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="result" expected="expectedWhitespace" id="whitespace" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeclonetruecopytext.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeclonetruecopytext"> |
| <metadata> |
| <title>nodeclonetruecopytext</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the second salary and |
| the "cloneNode(deep)" method with deep=true. The |
| duplicate node returned by the method should copy |
| any text data contained in this node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-3A0ED0A4"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="childList" type="NodeList"/> |
| <var name="childNode" type="Node"/> |
| <var name="clonedNode" type="Node"/> |
| <var name="lastChildNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"salary"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="childNode"/> |
| <cloneNode obj="childNode" deep="true" var="clonedNode"/> |
| <lastChild interface="Node" obj="clonedNode" var="lastChildNode"/> |
| <nodeValue obj="lastChildNode" var="childValue"/> |
| <assertEquals actual="childValue" expected='"35,000"' id="nodeCloneTrueCopyTextAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodecommentnodeattributes.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodecommentnodeattributes"> |
| <metadata> |
| <title>nodeCommentNodeAttributes</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method invoked on a Comment |
| Node returns null. |
| Find any comment that is an immediate child of the root |
| and assert that Node.attributes is null. Then create |
| a new comment node (in case they had been omitted) and |
| make the assertion. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1728279322"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=248"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="childNode" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="childList"/> |
| <for-each collection="childList" member="childNode"> |
| <nodeType var="nodeType" obj="childNode"/> |
| <if><equals actual="nodeType" expected="8"/> |
| <attributes obj="childNode" var="attrList"/> |
| <assertNull actual="attrList" id="attributesNull"/> |
| </if> |
| </for-each> |
| <createComment var="childNode" obj="doc" data='"This is a comment"'/> |
| <attributes obj="childNode" var="attrList"/> |
| <assertNull actual="attrList" id="createdAttributesNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodecommentnodename.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodecommentnodename"> |
| <metadata> |
| <title>nodeCommentNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| Comment Node is "#comment". |
| Retrieve the Comment node in the XML file |
| and check the string returned by the "getNodeName()" |
| method. It should be equal to "#comment". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1728279322"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="commentNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="commentNodeName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="elementList"/> |
| <for-each collection="elementList" member="commentNode"> |
| <nodeType obj="commentNode" var="nodeType"/> |
| <if> |
| <equals actual="nodeType" expected="8" ignoreCase="false"/> |
| <nodeName obj="commentNode" var="commentNodeName"/> |
| <assertEquals actual="commentNodeName" expected=""#comment"" |
| id="commentNodeName" ignoreCase="false"/> |
| </if> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodecommentnodetype.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodecommentnodetype"> |
| <metadata> |
| <title>nodeCommentNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for a Comment Node |
| returns the constant value 8. |
| Retrieve the nodes from the document and check for |
| a comment node and invoke the "getNodeType()" method. This should |
| return 8. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1728279322"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="testList" type="NodeList"/> |
| <var name="commentNode" type="Node"/> |
| <var name="commentNodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="testList"/> |
| <for-each collection="testList" member="commentNode"> |
| <nodeName obj="commentNode" var="commentNodeName"/> |
| <if> |
| <equals actual="commentNodeName" expected=""#comment"" ignoreCase="false"/> |
| <nodeType obj="commentNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="8" id="nodeCommentNodeTypeAssert1" ignoreCase="false"/> |
| </if> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodecommentnodevalue.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodecommentnodevalue"> |
| <metadata> |
| <title>nodeCommentNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| Comment Node is the content of the comment. |
| Retrieve the comment in the XML file and |
| check the string returned by the "getNodeValue()" method. |
| It should be equal to "This is comment number 1". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1728279322"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="commentNode" type="Node"/> |
| <var name="commentName" type="DOMString"/> |
| <var name="commentValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="elementList"/> |
| <for-each collection="elementList" member="commentNode"> |
| <nodeName obj="commentNode" var="commentName"/> |
| <if> |
| <equals actual="commentName" expected=""#comment"" ignoreCase="false"/> |
| <nodeValue obj="commentNode" var="commentValue"/> |
| <assertEquals actual="commentValue" expected="" This is comment number 1."" id="value" ignoreCase="false"/> |
| </if> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodedocumentfragmentnodename.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodedocumentfragmentnodename"> |
| <metadata> |
| <title>nodeDocumentFragmentNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| DocumentFragment Node is "#document-frament". |
| Retrieve the DOM document and invoke the |
| "createDocumentFragment()" method and check the string |
| returned by the "getNodeName()" method. It should be |
| equal to "#document-fragment". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A3"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="documentFragmentName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="docFragment"/> |
| <nodeName obj="docFragment" var="documentFragmentName"/> |
| <assertEquals actual="documentFragmentName" expected=""#document-fragment"" id="nodeDocumentFragmentNodeNameAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodedocumentfragmentnodetype.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodedocumentfragmentnodetype"> |
| <metadata> |
| <title>nodeDocumentFragmentNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for a DocumentFragment Node |
| returns the constant value 11. |
| Invoke the "createDocumentFragment()" method and |
| examine the NodeType of the document fragment |
| returned by the "getNodeType()" method. The method |
| should return 11. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A3"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="documentFragmentNode" type="DocumentFragment"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="documentFragmentNode"/> |
| <nodeType obj="documentFragmentNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="11" id="nodeDocumentFragmentNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodedocumentfragmentnodevalue.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodedocumentfragmentnodevalue"> |
| <metadata> |
| <title>nodeDocumentFragmentNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| DocumentFragment Node is null. |
| Retrieve the DOM document and invoke the |
| "createDocumentFragment()" method and check the string |
| returned by the "getNodeValue()" method. It should be |
| equal to null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A3"/> |
| <!--nodeValue attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <!-- Node.attributes --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="docFragment"/> |
| <!-- despite the name, this was the only assertion in the original test --> |
| <attributes obj="docFragment" var="attrList"/> |
| <assertNull actual="attrList" id="attributesNull"/> |
| <!-- now actually test the initial value of nodeValue --> |
| <nodeValue obj="docFragment" var="value"/> |
| <assertNull actual="value" id="initiallyNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodedocumentnodeattribute.xml |
|---|
| 0,0 → 1,34 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodedocumentnodeattribute"> |
| <metadata> |
| <title>nodedocumentnodeattribute</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method invoked on a Document |
| Node returns null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- Document interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <attributes obj="doc" var="attrList"/> |
| <assertNull actual="attrList" id="documentAttributesNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodedocumentnodename.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodedocumentnodename"> |
| <metadata> |
| <title>nodeDocumentNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| Document Node is "#document". |
| Retrieve the DOM document and check the string returned |
| by the "getNodeName()" method. It should be equal to |
| "#document". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- Document interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="documentName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <nodeName obj="doc" var="documentName"/> |
| <assertEquals actual="documentName" expected=""#document"" |
| id="documentNodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodedocumentnodetype.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodedocumentnodetype"> |
| <metadata> |
| <title>nodeDocumentNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for a Document Node |
| returns the constant value 9. |
| Retrieve the document and invoke the "getNodeType()" |
| method. The method should return 9. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- Document interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <nodeType obj="doc" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="9" id="nodeDocumentNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodedocumentnodevalue.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodedocumentnodevalue"> |
| <metadata> |
| <title>nodeDocumentNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| Document Node is null. |
| Retrieve the DOM Document and check the string returned |
| by the "getNodeValue()" method. It should be equal to |
| null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!-- Document interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="documentValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <nodeValue obj="doc" var="documentValue"/> |
| <assertNull actual="documentValue" id="documentNodeValueNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodedocumenttypenodename.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodedocumenttypenodename"> |
| <metadata> |
| <title>nodedocumenttypenodename</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the DOCTYPE declaration from the XML file and |
| check the string returned by the "getNodeName()" |
| method. It should be equal to "staff" or "svg". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="documentTypeName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <nodeName obj="docType" var="documentTypeName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="documentTypeName" expected='"svg"' id="doctypeNameSVG" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="documentTypeName" expected='"staff"' id="documentName" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodedocumenttypenodetype.xml |
|---|
| 0,0 → 1,34 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodedocumenttypenodetype"> |
| <metadata> |
| <title>nodedocumenttypenodetype</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for a DocumentType Node |
| returns the constant value 10. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="documentTypeNode" type="DocumentType"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="documentTypeNode"/> |
| <assertNotNull actual="documentTypeNode" id="doctypeNotNull"/> |
| <nodeType obj="documentTypeNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="10" id="nodeType" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodedocumenttypenodevalue.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodedocumenttypenodevalue"> |
| <metadata> |
| <title>nodedocumenttypenodevalue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| DocumentType Node is null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <attributes obj="docType" var="attrList"/> |
| <assertNull actual="attrList" id="doctypeAttributesNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeelementnodeattributes.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeelementnodeattributes"> |
| <metadata> |
| <title>nodeElementNodeAttributes</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method invoked on an Element |
| Node returns a NamedNodeMap containing the attributes |
| of this node. |
| Retrieve the last child of the third employee and |
| invoke the "getAttributes()" method. It should return |
| a NamedNodeMap containing the attributes of the Element |
| node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="NamedNodeMap"/> |
| <var name="attrNode" type="Node"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="attrList" type="Collection"/> |
| <var name="expected" type="Collection"> |
| <member>"domestic"</member> |
| <member>"street"</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="testAddr"/> |
| <attributes obj="testAddr" var="addrAttr"/> |
| <for-each collection="addrAttr" member="attrNode"> |
| <nodeName obj="attrNode" var="attrName"/> |
| <append collection="attrList" item="attrName"/> |
| </for-each> |
| <assertEquals actual="attrList" expected="expected" id="nodeElementNodeValueAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeelementnodename.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeelementnodename"> |
| <metadata> |
| <title>nodeElementNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeName()" method for an |
| Element Node is its tagName. |
| Retrieve the first Element Node(Root Node) of the |
| DOM object and check the string returned by the |
| "getNodeName()" method. It should be equal to its |
| tagName. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=251"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementNode" type="Element"/> |
| <var name="elementName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="elementNode"/> |
| <nodeName obj="elementNode" var="elementName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="elementName" expected='"svg"' id="svgNodeName" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="elementName" expected='"staff"' id="nodeElementNodeNameAssert1" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeelementnodetype.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeelementnodetype"> |
| <metadata> |
| <title>nodeElementNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for an Element Node |
| returns the constant value 1. |
| Retrieve the root node and invoke the "getNodeType()" |
| method. The method should return 1. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Element"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <nodeType obj="rootNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="1" id="nodeElementNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeelementnodevalue.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeelementnodevalue"> |
| <metadata> |
| <title>nodeElementNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for an |
| Element Node is null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementNode" type="Element"/> |
| <var name="elementValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="elementNode"/> |
| <nodeValue obj="elementNode" var="elementValue"/> |
| <assertNull actual="elementValue" id="elementNodeValueNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeentitynodeattributes.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeentitynodeattributes"> |
| <metadata> |
| <title>nodeentitynodeattributes</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method invoked on an Entity |
| Node returns null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entityNode" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entities"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <getNamedItem obj="entities" name='"ent1"' var="entityNode"/> |
| <assertNotNull actual="entityNode" id="ent1NotNull"/> |
| <attributes obj="entityNode" var="attrList"/> |
| <assertNull actual="attrList" id="entityAttributesNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeentitynodename.xml.kfail |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeentitynodename"> |
| <metadata> |
| <title>nodeEntityNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| Check the nodeName of the entity returned by DocumentType.entities.getNamedItem("ent1"). |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entityNode" type="Node"/> |
| <var name="entityName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entities"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <getNamedItem obj="entities" name='"ent1"' var="entityNode"/> |
| <assertNotNull actual="entityNode" id="entityNodeNotNull"/> |
| <nodeName obj="entityNode" var="entityName"/> |
| <assertEquals actual="entityName" expected='"ent1"' id="entityNodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeentitynodetype.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeentitynodetype"> |
| <metadata> |
| <title>nodeEntityNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for an Entity Node |
| returns the constant value 6. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entityNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entities"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <getNamedItem obj="entities" var="entityNode" name='"ent1"'/> |
| <assertNotNull actual="entityNode" id="ent1NotNull"/> |
| <nodeType obj="entityNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="6" id="entityNodeType" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeentitynodevalue.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeentitynodevalue"> |
| <metadata> |
| <title>nodeEntityNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for an |
| Entity Node is null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entityNode" type="Node"/> |
| <var name="entityValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entities"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <getNamedItem obj="entities" name='"ent1"' var="entityNode"/> |
| <assertNotNull actual="entityNode" id="ent1NotNull"/> |
| <nodeValue obj="entityNode" var="entityValue"/> |
| <assertNull actual="entityValue" id="entityNodeValue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeentityreferencenodeattributes.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeentityreferencenodeattributes"> |
| <metadata> |
| <title>nodeentityreferencenodeattributes</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method invoked on an EntityReference |
| Node returns null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="entRefAddr" type="Element"/> |
| <var name="entRefNode" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"address"'/> |
| <item interface="NodeList" obj="elementList" index="1" var="entRefAddr"/> |
| <firstChild interface="Node" obj="entRefAddr" var="entRefNode"/> |
| <nodeType var="nodeType" obj="entRefNode"/> |
| <if><notEquals actual="nodeType" expected="5" ignoreCase="false"/> |
| <createEntityReference var="entRefNode" obj="doc" name='"ent2"'/> |
| <assertNotNull actual="entRefNode" id="createdEntRefNotNull"/> |
| </if> |
| <attributes obj="entRefNode" var="attrList"/> |
| <assertNull actual="attrList" id="attrList"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeentityreferencenodename.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeentityreferencenodename"> |
| <metadata> |
| <title>nodeEntityReferenceNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeName()" method for an |
| EntityReference Node is the name of the entity referenced. |
| Retrieve the first Entity Reference node from the last |
| child of the second employee and check the string |
| returned by the "getNodeName()" method. It should be |
| equal to "ent2". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="entRefAddr" type="Element"/> |
| <var name="entRefNode" type="Node"/> |
| <var name="entRefName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" |
| var="elementList" tagname='"address"'/> |
| <item interface="NodeList" obj="elementList" index="1" var="entRefAddr"/> |
| <firstChild interface="Node" obj="entRefAddr" var="entRefNode"/> |
| <nodeType var="nodeType" obj="entRefNode"/> |
| <if><notEquals actual="nodeType" expected="5" ignoreCase="false"/> |
| <createEntityReference var="entRefNode" obj="doc" name='"ent2"'/> |
| <assertNotNull actual="entRefNode" id="createdEntRefNotNull"/> |
| </if> |
| <nodeName obj="entRefNode" var="entRefName"/> |
| <assertEquals actual="entRefName" expected='"ent2"' id="nodeEntityReferenceNodeNameAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeentityreferencenodetype.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeentityreferencenodetype"> |
| <metadata> |
| <title>nodeEntityReferenceNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for an EntityReference Node |
| returns the constant value 5. |
| Retrieve the EntityReference node from the last child |
| of the second employee and invoke the "getNodeType()" |
| method. The method should return 5. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="entRefAddr" type="Element"/> |
| <var name="entRefNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" |
| var="elementList" tagname='"address"'/> |
| <item interface="NodeList" obj="elementList" index="1" var="entRefAddr"/> |
| <firstChild interface="Node" obj="entRefAddr" var="entRefNode"/> |
| <nodeType obj="entRefNode" var="nodeType"/> |
| <if><equals actual="nodeType" expected="3" ignoreCase="false"/> |
| <createEntityReference var="entRefNode" obj="doc" name='"ent2"'/> |
| <assertNotNull actual="entRefNode" id="createdEntRefNotNull"/> |
| <nodeType obj="entRefNode" var="nodeType"/> |
| </if> |
| <assertEquals actual="nodeType" expected="5" id="entityNodeType" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeentityreferencenodevalue.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeentityreferencenodevalue"> |
| <metadata> |
| <title>nodeEntityReferenceNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for an |
| EntityReference Node is null. |
| Retrieve the first Entity Reference node from the last |
| child of the second employee and check the string |
| returned by the "getNodeValue()" method. It should be |
| equal to null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="entRefAddr" type="Element"/> |
| <var name="entRefNode" type="Node"/> |
| <var name="entRefValue" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" |
| var="elementList" tagname='"address"'/> |
| <item interface="NodeList" obj="elementList" index="1" var="entRefAddr"/> |
| <firstChild interface="Node" obj="entRefAddr" var="entRefNode"/> |
| <nodeType var="nodeType" obj="entRefNode"/> |
| <if><equals actual="nodeType" expected="3" ignoreCase="false"/> |
| <createEntityReference var="entRefNode" obj="doc" name='"ent2"'/> |
| <assertNotNull actual="entRefNode" id="createdEntRefNotNull"/> |
| </if> |
| <nodeValue obj="entRefNode" var="entRefValue"/> |
| <assertNull actual="entRefValue" id="entRefNodeValue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeentitysetnodevalue.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeentitysetnodevalue"> |
| <metadata> |
| <title>nodeentitysetnodevalue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for an |
| Entity Node is always null and "setNodeValue" should have no effect. |
| </description> |
| <date qualifier="created">2001-10-21</date> |
| <!-- Node.nodeValue --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <!-- Entity interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-527DCFF2"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entityNode" type="Node"/> |
| <var name="entityValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="entities"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <getNamedItem obj="entities" name='"ent1"' var="entityNode"/> |
| <assertNotNull actual="entityNode" id="ent1NotNull"/> |
| <nodeValue obj="entityNode" value='"This should have no effect"'/> |
| <nodeValue obj="entityNode" var="entityValue"/> |
| <assertNull actual="entityValue" id="nodeValueNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodegetfirstchild.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodegetfirstchild"> |
| <metadata> |
| <title>nodegetfirstchild</title> |
| <creator>NIST</creator> |
| <description> |
| The "getFirstChild()" method returns the first child |
| of this node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-169727388"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="fchildNode" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <firstChild interface="Node" obj="employeeNode" var="fchildNode"/> |
| <nodeName obj="fchildNode" var="childName"/> |
| <if><equals actual="childName" expected='"#text"' ignoreCase="false"/> |
| <nextSibling var="fchildNode" obj="fchildNode" interface="Node"/> |
| <nodeName obj="fchildNode" var="childName"/> |
| </if> |
| <assertEquals actual="childName" expected='"employeeId"' id="nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodegetfirstchildnull.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodegetfirstchildnull"> |
| <metadata> |
| <title>nodeGetFirstChildNull</title> |
| <creator>NIST</creator> |
| <description> |
| If there is not a first child then the "getFirstChild()" |
| method returns null. |
| Retrieve the Text node form the second child of the first |
| employee and invoke the "getFirstChild()" method. It |
| should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-169727388"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="secondChildNode" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="noChildNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <item interface="NodeList" obj="employeeList" index="1" var="secondChildNode"/> |
| <firstChild interface="Node" obj="secondChildNode" var="textNode"/> |
| <firstChild interface="Node" obj="textNode" var="noChildNode"/> |
| <assertNull actual="noChildNode" id="nodeGetFirstChildNullAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodegetlastchild.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodegetlastchild"> |
| <metadata> |
| <title>nodegetlastchild</title> |
| <creator>NIST</creator> |
| <description> |
| The "getLastChild()" method returns the last child |
| of this node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-61AD09FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="lchildNode" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <lastChild interface="Node" obj="employeeNode" var="lchildNode"/> |
| <nodeName obj="lchildNode" var="childName"/> |
| <if><equals actual="childName" expected='"#text"' ignoreCase="false"/> |
| <previousSibling interface="Node" obj="lchildNode" var="lchildNode"/> |
| <nodeName obj="lchildNode" var="childName"/> |
| </if> |
| <assertEquals actual="childName" expected='"address"' id="nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodegetlastchildnull.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodegetlastchildnull"> |
| <metadata> |
| <title>nodeGetLastChildNull</title> |
| <creator>NIST</creator> |
| <description> |
| If there is not a last child then the "getLastChild()" |
| method returns null. |
| Retrieve the Text node from the second child of the first |
| employee and invoke the "getLastChild()" method. It |
| should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-61AD09FB"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="secondChildNode" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="noChildNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <item interface="NodeList" obj="employeeList" index="1" var="secondChildNode"/> |
| <firstChild interface="Node" obj="secondChildNode" var="textNode"/> |
| <lastChild interface="Node" obj="textNode" var="noChildNode"/> |
| <assertNull actual="noChildNode" id="nodeGetLastChildNullAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodegetnextsibling.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodegetnextsibling"> |
| <metadata> |
| <title>nodegetnextsibling</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNextSibling()" method returns the node immediately |
| following this node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6AC54C2F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeIdNode" type="Node"/> |
| <var name="nsNode" type="Node"/> |
| <var name="nsName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employeeId"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeIdNode"/> |
| <nextSibling interface="Node" obj="employeeIdNode" var="nsNode"/> |
| <nodeName obj="nsNode" var="nsName"/> |
| <if><equals actual="nsName" expected='"#text"' ignoreCase="false"/> |
| <nextSibling interface="Node" obj="nsNode" var="nsNode"/> |
| <nodeName obj="nsNode" var="nsName"/> |
| </if> |
| <assertEquals actual="nsName" expected='"name"' id="nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodegetnextsiblingnull.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodegetnextsiblingnull"> |
| <metadata> |
| <title>nodeGetNextSiblingNull</title> |
| <creator>NIST</creator> |
| <description> |
| If there is not a node immediately following this node the |
| "getNextSibling()" method returns null. |
| Retrieve the first child of the second employee and |
| invoke the "getNextSibling()" method. It should |
| be set to null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-6AC54C2F"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="lcNode" type="Node"/> |
| <var name="nsNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <lastChild interface="Node" obj="employeeNode" var="lcNode"/> |
| <nextSibling interface="Node" obj="lcNode" var="nsNode"/> |
| <assertNull actual="nsNode" id="nodeGetNextSiblingNullAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodegetownerdocument.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodegetownerdocument"> |
| <metadata> |
| <title>nodeGetOwnerDocument</title> |
| <creator>NIST</creator> |
| <description> |
| The "getOwnerDocument()" method returns the Document |
| object associated with this node. |
| Retrieve the second employee and examine Document |
| returned by the "getOwnerDocument()" method. Invoke |
| the "getDocumentElement()" on the Document which will |
| return an Element that is equal to "staff". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#node-ownerDoc"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=251"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="docNode" type="Node"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docElement" type="Element"/> |
| <var name="elementName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="docNode"/> |
| <ownerDocument obj="docNode" var="ownerDocument"/> |
| <documentElement obj="ownerDocument" var="docElement"/> |
| <nodeName obj="docElement" var="elementName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="elementName" expected='"svg"' id="svgTagName" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="elementName" expected=""staff"" id="nodeGetOwnerDocumentAssert1" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodegetownerdocumentnull.xml |
|---|
| 0,0 → 1,31 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodegetownerdocumentnull"> |
| <metadata> |
| <title>nodeGetOwnerDocumentNull</title> |
| <creator>NIST</creator> |
| <description> |
| The "getOwnerDocument()" method returns null if the target |
| node itself is a document. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#node-ownerDoc"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="ownerDocument" type="Document"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <ownerDocument obj="doc" var="ownerDocument"/> |
| <assertNull actual="ownerDocument" id="documentOwnerDocumentNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodegetprevioussibling.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodegetprevioussibling"> |
| <metadata> |
| <title>nodegetprevioussibling</title> |
| <creator>NIST</creator> |
| <description> |
| The "getPreviousSibling()" method returns the node |
| immediately preceding this node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-640FB3C8"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="psNode" type="Node"/> |
| <var name="psName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="nameNode"/> |
| <previousSibling interface="Node" obj="nameNode" var="psNode"/> |
| <nodeName obj="psNode" var="psName"/> |
| <if><equals actual="psName" expected='"#text"' ignoreCase="false"/> |
| <previousSibling interface="Node" obj="psNode" var="psNode"/> |
| <nodeName obj="psNode" var="psName"/> |
| </if> |
| <assertEquals actual="psName" expected='"employeeId"' id="nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodegetprevioussiblingnull.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodegetprevioussiblingnull"> |
| <metadata> |
| <title>nodeGetPreviousSiblingNull</title> |
| <creator>NIST</creator> |
| <description> |
| If there is not a node immediately preceding this node the |
| "getPreviousSibling()" method returns null. |
| Retrieve the first child of the second employee and |
| invoke the "getPreviousSibling()" method. It should |
| be set to null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-640FB3C8"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="fcNode" type="Node"/> |
| <var name="psNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="employeeNode"/> |
| <firstChild interface="Node" obj="employeeNode" var="fcNode"/> |
| <previousSibling interface="Node" obj="fcNode" var="psNode"/> |
| <assertNull actual="psNode" id="nodeGetPreviousSiblingNullAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodehaschildnodes.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodehaschildnodes"> |
| <metadata> |
| <title>nodeHasChildNodes</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasChildNodes()" method returns true if the node |
| has children. |
| Retrieve the root node("staff") and invoke the |
| "hasChildNodes()" method. It should return the boolean |
| value "true". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-810594187"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <hasChildNodes obj="employeeNode" var="state"/> |
| <assertTrue actual="state" id="nodeHasChildAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodehaschildnodesfalse.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodehaschildnodesfalse"> |
| <metadata> |
| <title>nodeHasChildNodesFalse</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasChildNodes()" method returns false if the node |
| does not have any children. |
| Retrieve the Text node inside the first child of the |
| second employee and invoke the "hasChildNodes()" method. |
| It should return the boolean value "false". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-810594187"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="employeeIdList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="child"/> |
| <childNodes obj="child" var="employeeIdList"/> |
| <item interface="NodeList" obj="employeeIdList" index="1" var="employeeNode"/> |
| <firstChild interface="Node" obj="employeeNode" var="textNode"/> |
| <hasChildNodes obj="textNode" var="state"/> |
| <assertFalse actual="state" id="nodeHasChildFalseAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbefore.xml.int-broken |
|---|
| 0,0 → 1,87 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbefore"> |
| <metadata> |
| <title>nodeInsertBefore</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method inserts the |
| node "newChild" before the node "refChild". |
| Insert a newly created Element node before the eigth |
| child of the second employee and check the "newChild" |
| and "refChild" after insertion for correct placement. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="length" type="int"/> |
| <var name="insertedNode" type="Node"/> |
| <var name="actual" type="List"/> |
| <var name="expectedWithWhitespace" type="List"> |
| <member>"#text"</member> |
| <member>"employeeId"</member> |
| <member>"#text"</member> |
| <member>"name"</member> |
| <member>"#text"</member> |
| <member>"position"</member> |
| <member>"#text"</member> |
| <member>"newChild"</member> |
| <member>"salary"</member> |
| <member>"#text"</member> |
| <member>"gender"</member> |
| <member>"#text"</member> |
| <member>"address"</member> |
| <member>"#text"</member> |
| </var> |
| <var name="expectedWithoutWhitespace" type="List"> |
| <member>"employeeId"</member> |
| <member>"name"</member> |
| <member>"position"</member> |
| <member>"newChild"</member> |
| <member>"salary"</member> |
| <member>"gender"</member> |
| <member>"address"</member> |
| </var> |
| <var name="expected" type="List"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <length var="length" obj="childList" interface="NodeList"/> |
| <if><equals actual="length" expected="6" ignoreCase="false"/> |
| <item interface="NodeList" obj="childList" index="3" var="refChild"/> |
| <assign var="expected" value="expectedWithoutWhitespace"/> |
| <else> |
| <item interface="NodeList" obj="childList" index="7" var="refChild"/> |
| <assign var="expected" value="expectedWithWhitespace"/> |
| </else> |
| </if> |
| <createElement obj="doc" tagName='"newChild"' var="newChild"/> |
| <insertBefore var="insertedNode" obj="employeeNode" newChild="newChild" refChild="refChild"/> |
| <for-each collection="childList" member="child"> |
| <nodeName obj="child" var="childName"/> |
| <append collection="actual" item="childName"/> |
| </for-each> |
| <assertEquals actual="actual" expected="expected" id="nodeNames" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbeforedocfragment.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbeforedocfragment"> |
| <metadata> |
| <title>nodeInsertBeforeDocFragment</title> |
| <creator>NIST</creator> |
| <description> |
| If the "newChild" is a DocumentFragment object then all |
| its children are inserted in the same order before the |
| the "refChild". |
| Create a DocumentFragment object and populate it with |
| two Element nodes. Retrieve the second employee and |
| insert the newly created DocumentFragment before its |
| fourth child. The second employee should now have two |
| extra children("newChild1" and "newChild2") at |
| positions fourth and fifth respectively. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="newdocFragment" type="DocumentFragment"/> |
| <var name="newChild1" type="Node"/> |
| <var name="newChild2" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="3" var="refChild"/> |
| <createDocumentFragment obj="doc" var="newdocFragment"/> |
| <createElement obj="doc" tagName=""newChild1"" var="newChild1"/> |
| <createElement obj="doc" tagName=""newChild2"" var="newChild2"/> |
| <appendChild var="appendedChild" obj="newdocFragment" newChild="newChild1"/> |
| <appendChild var="appendedChild" obj="newdocFragment" newChild="newChild2"/> |
| <insertBefore var="insertedNode" obj="employeeNode" newChild="newdocFragment" refChild="refChild"/> |
| <item interface="NodeList" obj="childList" index="3" var="child"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"newChild1"' ignoreCase="false" id="childName3"/> |
| <item interface="NodeList" obj="childList" index="4" var="child"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"newChild2"' ignoreCase="false" id="childName4"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbeforeinvalidnodetype.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbeforeinvalidnodetype"> |
| <metadata> |
| <title>nodeInsertBeforeInvalidNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if this node is of |
| a type that does not allow children of the type "newChild" |
| to be inserted. |
| Retrieve the root node and attempt to insert a newly |
| created Attr node. An Element node cannot have children |
| of the "Attr" type, therefore the desired exception |
| should be raised. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-952280727')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Element"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <createAttribute obj="doc" name=""newAttribute"" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="refChild"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore var="insertedNode" obj="rootNode" newChild="newChild" refChild="refChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbeforenewchilddiffdocument.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbeforenewchilddiffdocument"> |
| <metadata> |
| <title>nodeInsertBeforeNewChildDiffDocument</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method raises a |
| WRONG_DOCUMENT_ERR DOMException if the "newChild" was |
| created from a different document than the one that |
| created this node. |
| Retrieve the second employee and attempt to insert a new |
| child that was created from a different document than the |
| one that created the second employee. An attempt to |
| insert such a child should raise the desired exception. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-952280727')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="refChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc1" href="staff" willBeModified="false"/> |
| <load var="doc2" href="staff" willBeModified="true"/> |
| <createElement obj="doc1" tagName=""newChild"" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc2" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <firstChild var="refChild" obj="elementNode" interface="Node"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <insertBefore var="insertedNode" obj="elementNode" newChild="newChild" refChild="refChild"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbeforenewchildexists.xml.int-broken |
|---|
| 0,0 → 1,89 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbeforenewchildexists"> |
| <metadata> |
| <title>nodeInsertBeforeNewChildExists</title> |
| <creator>NIST</creator> |
| <description> |
| If the "newChild" is already in the tree, the |
| "insertBefore(newChild,refChild)" method must first |
| remove it before the insertion takes place. |
| Insert a node Element ("employeeId") that is already |
| present in the tree. The existing node should be |
| removed first and the new one inserted. The node is |
| inserted at a different position in the tree to assure |
| that it was indeed inserted. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="length" type="int"/> |
| <var name="childName" type="DOMString"/> |
| <var name="insertedNode" type="Node"/> |
| <var name="expectedWhitespace" type="List"> |
| <member>"#text"</member> |
| <member>"#text"</member> |
| <member>"name"</member> |
| <member>"#text"</member> |
| <member>"position"</member> |
| <member>"#text"</member> |
| <member>"salary"</member> |
| <member>"#text"</member> |
| <member>"gender"</member> |
| <member>"#text"</member> |
| <member>"employeeId"</member> |
| <member>"address"</member> |
| <member>"#text"</member> |
| </var> |
| <var name="expectedNoWhitespace" type="List"> |
| <member>"name"</member> |
| <member>"position"</member> |
| <member>"salary"</member> |
| <member>"gender"</member> |
| <member>"employeeId"</member> |
| <member>"address"</member> |
| </var> |
| <var name="expected" type="List"/> |
| <var name="result" type="List"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <length var="length" obj="childList" interface="NodeList"/> |
| <if><equals actual="length" expected="6" ignoreCase="false"/> |
| <assign var="expected" value="expectedNoWhitespace"/> |
| <item interface="NodeList" obj="childList" index="5" var="refChild"/> |
| <item interface="NodeList" obj="childList" index="0" var="newChild"/> |
| <else> |
| <assign var="expected" value="expectedWhitespace"/> |
| <item interface="NodeList" obj="childList" index="11" var="refChild"/> |
| <item interface="NodeList" obj="childList" index="1" var="newChild"/> |
| </else> |
| </if> |
| <insertBefore var="insertedNode" obj="employeeNode" newChild="newChild" refChild="refChild"/> |
| <for-each collection="childList" member="child"> |
| <nodeName obj="child" var="childName"/> |
| <append collection="result" item="childName"/> |
| </for-each> |
| <assertEquals id="childNames" actual="result" expected="expected" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbeforenodeancestor.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbeforenodeancestor"> |
| <metadata> |
| <title>nodeInsertBeforeNodeAncestor</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if the node to be |
| inserted is one of this nodes ancestors. |
| Retrieve the second employee and attempt to insert a |
| node that is one of its ancestors(root node). An |
| attempt to insert such a node should raise the |
| desired exception. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-952280727')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <documentElement obj="doc" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="0" var="refChild"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore var="insertedNode" obj="employeeNode" newChild="newChild" refChild="refChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbeforenodename.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbeforenodename"> |
| <metadata> |
| <title>nodeInsertBeforeNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertBefore(newChild,refchild)" method returns |
| the node being inserted. |
| Insert an Element node before the fourth |
| child of the second employee and check the node |
| returned from the "insertBefore(newChild,refChild)" |
| method. The node returned should be "newChild". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="3" var="refChild"/> |
| <createElement obj="doc" tagName=""newChild"" var="newChild"/> |
| <insertBefore obj="employeeNode" newChild="newChild" refChild="refChild" var="insertedNode"/> |
| <nodeName obj="insertedNode" var="childName"/> |
| <assertEquals actual="childName" expected=""newChild"" id="nodeInsertBeforeNodeNameAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbeforenomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbeforenomodificationallowederr"> |
| <metadata> |
| <title>nodeInsertBeforeNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the FIRST item |
| from the entity reference and execute the "insertBefore(newChild,refChild)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-952280727')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entRef" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="createdNode" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <var name="refChild" type="Node" isNull="true"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item obj="genderList" index="2" var="genderNode" interface="NodeList"/> |
| <firstChild interface="Node" var="entRef" obj="genderNode"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <nodeType var="nodeType" obj="entRef"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <createElement obj="doc" tagName='"text3"' var="createdNode"/> |
| <assertDOMException id="throw_NOT_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertBefore var="insertedNode" obj="entElement" newChild="createdNode" refChild="refChild"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbeforenomodificationallowederrEE.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbeforenomodificationallowederrEE"> |
| <metadata> |
| <title>nodeInsertBeforeNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Create an ent4 entity reference and and execute the "insertBefore(newChild,refChild)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-21</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-952280727')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/nodeinsertbeforenomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="Node"/> |
| <var name="createdNode" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <var name="refChild" type="Node" isNull="true"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <createElement obj="doc" tagName='"text3"' var="createdNode"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertBefore var="insertedNode" obj="entRef" newChild="createdNode" refChild="refChild"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbeforerefchildnonexistent.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbeforerefchildnonexistent"> |
| <metadata> |
| <title>nodeInsertBeforeRefChildNonexistent</title> |
| <creator>NIST</creator> |
| <description> |
| The "insertBefore(newChild,refChild)" method raises a |
| NOT_FOUND_ERR DOMException if the reference child is |
| not a child of this node. |
| Retrieve the second employee and attempt to insert a |
| new node before a reference node that is not a child |
| of this node. An attempt to insert before a non child |
| node should raise the desired exception. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-952280727')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="refChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createElement obj="doc" tagName=""newChild"" var="newChild"/> |
| <createElement obj="doc" tagName=""refChild"" var="refChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <insertBefore var="insertedNode" obj="elementNode" newChild="newChild" refChild="refChild"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeinsertbeforerefchildnull.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeinsertbeforerefchildnull"> |
| <metadata> |
| <title>nodeInsertBeforeRefChildNull</title> |
| <creator>NIST</creator> |
| <description> |
| If the "refChild" is null then the |
| "insertBefore(newChild,refChild)" method inserts the |
| node "newChild" at the end of the list of children. |
| Retrieve the second employee and invoke the |
| "insertBefore(newChild,refChild)" method with |
| refChild=null. Since "refChild" is null the "newChild" |
| should be added to the end of the list. The last item |
| in the list is checked after insertion. The last Element |
| node of the list should be "newChild". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="refChild" type="Node" isNull="true"/> |
| <var name="newChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="insertedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <createElement obj="doc" tagName=""newChild"" var="newChild"/> |
| <insertBefore var="insertedNode" obj="employeeNode" newChild="newChild" refChild="refChild"/> |
| <lastChild interface="Node" obj="employeeNode" var="child"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected=""newChild"" id="nodeInsertBeforeRefChildNullAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodelistindexequalzero.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodelistindexequalzero"> |
| <metadata> |
| <title>nodelistindexequalzero</title> |
| <creator>NIST</creator> |
| <description> |
| Create a list of all the children elements of the third |
| employee and access its first child by using an index |
| of 0. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--item--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-844377136"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"employee"'/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <item interface="NodeList" obj="employeeList" var="child" index="0"/> |
| <nodeName obj="child" var="childName"/> |
| <if><notEquals actual="childName" expected='"#text"' ignoreCase="false"/> |
| <assertEquals actual="childName" expected='"employeeId"' id="childName" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodelistindexgetlength.xml.int-broken |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodelistindexgetlength"> |
| <metadata> |
| <title>nodelistIndexGetLength</title> |
| <creator>NIST</creator> |
| <description> |
| The "getLength()" method returns the number of nodes |
| in the list should be 6 (no whitespace) or 13. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--length attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-203510337"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="length" type="int"/> |
| <var name="expectedCount" type="int" value="0"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""employee""/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <length var="length" obj="employeeList" interface="NodeList"/> |
| <assertTrue id="lengthIs6or13"> |
| <or> |
| <equals actual="length" expected="6" ignoreCase="false"/> |
| <equals actual="length" expected="13" ignoreCase="false"/> |
| </or> |
| </assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodelistindexgetlengthofemptylist.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodelistindexgetlengthofemptylist"> |
| <metadata> |
| <title>nodelistIndexGetLengthOfEmptyList</title> |
| <creator>NIST</creator> |
| <description> |
| The "getLength()" method returns the number of nodes |
| in the list.(Test for EMPTY list) |
| Create a list of all the children of the Text node |
| inside the first child of the third employee and |
| invoke the "getLength()" method. It should contain |
| the value 0. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--length attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-203510337"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="childNode" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="textList" type="NodeList"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""employee""/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <item interface="NodeList" obj="employeeList" var="childNode" index="1"/> |
| <firstChild interface="Node" obj="childNode" var="textNode"/> |
| <childNodes obj="textNode" var="textList"/> |
| <assertSize collection="textList" size="0" id="nodelistIndexGetLengthOfEmptyListAssert"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodelistindexnotzero.xml.int-broken |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodelistindexnotzero"> |
| <metadata> |
| <title>nodelistIndexNotZero</title> |
| <creator>NIST</creator> |
| <description> |
| Create a list of all the children elements of the third |
| employee and access its fourth child by using an index |
| of 3. This should result in "name" being |
| selected. Further we evaluate its content(by using |
| the "getNodeName()" method) to ensure the proper |
| element was accessed. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--item--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-844377136"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="length" type="int"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""employee""/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <length var="length" obj="employeeList" interface="NodeList"/> |
| <if><equals actual="length" expected="6" ignoreCase="false"/> |
| <item interface="NodeList" obj="employeeList" var="child" index="1"/> |
| <else> |
| <item interface="NodeList" obj="employeeList" var="child" index="3"/> |
| </else> |
| </if> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"name"' |
| id="nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodelistreturnfirstitem.xml.int-broken |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodelistreturnfirstitem"> |
| <metadata> |
| <title>nodelistReturnFirstItem</title> |
| <creator>NIST</creator> |
| <description> |
| Get the first child of the third employee using NodeList.item(0) |
| which will either be a Text node (whitespace) or employeeId element. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-844377136"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"employee"'/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <item interface="NodeList" obj="employeeList" var="child" index="0"/> |
| <nodeName obj="child" var="childName"/> |
| <length var="length" obj="employeeList" interface="NodeList"/> |
| <if><equals actual="length" expected="6" ignoreCase="false"/> |
| <assertEquals actual="childName" expected='"employeeId"' ignoreCase="true" id="firstChildNoWhitespace"/> |
| <else> |
| <assertEquals actual="childName" expected='"#text"' ignoreCase="true" id="firstChildWithWhitespace"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodelistreturnlastitem.xml.int-broken |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodelistreturnlastitem"> |
| <metadata> |
| <title>nodelistReturnLastItem</title> |
| <creator>NIST</creator> |
| <description> |
| Get this last child of the third employee using NodeList.item(NodeList.length - 1) |
| and check that it is either a Text element (with whitespace) or an address element. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-844377136"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""employee""/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <length var="length" obj="employeeList" interface="NodeList"/> |
| <if><equals actual="length" expected="6" ignoreCase="false"/> |
| <item interface="NodeList" obj="employeeList" var="child" index="5"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"address"' id="nodeName1" ignoreCase="false"/> |
| <else> |
| <item interface="NodeList" obj="employeeList" var="child" index="12"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"#text"' id="nodeName2" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodelisttraverselist.xml.int-broken |
|---|
| 0,0 → 1,78 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodelisttraverselist"> |
| <metadata> |
| <title>nodelistTraverseList</title> |
| <creator>NIST</creator> |
| <description> |
| The range of valid child node indices is 0 thru length -1 |
| Create a list of all the children elements of the third |
| employee and traverse the list from index=0 thru |
| length -1. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--length attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-203510337"/> |
| <!--item--> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-844377136"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="length" type="int"/> |
| <var name="expectedWhitespace" type="List"> |
| <member>"#text"</member> |
| <member>"employeeId"</member> |
| <member>"#text"</member> |
| <member>"name"</member> |
| <member>"#text"</member> |
| <member>"position"</member> |
| <member>"#text"</member> |
| <member>"salary"</member> |
| <member>"#text"</member> |
| <member>"gender"</member> |
| <member>"#text"</member> |
| <member>"address"</member> |
| <member>"#text"</member> |
| </var> |
| <var name="expectedNoWhitespace" type="List"> |
| <member>"employeeId"</member> |
| <member>"name"</member> |
| <member>"position"</member> |
| <member>"salary"</member> |
| <member>"gender"</member> |
| <member>"address"</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""employee""/> |
| <item interface="NodeList" obj="elementList" var="employeeNode" index="2"/> |
| <childNodes obj="employeeNode" var="employeeList"/> |
| <length var="length" obj="employeeList" interface="NodeList"/> |
| <for-each collection="employeeList" member="child"> |
| <nodeName obj="child" var="childName"/> |
| <append collection="result" item="childName"/> |
| </for-each> |
| <if><equals actual="length" expected="6" ignoreCase="false"/> |
| <assertEquals actual="result" expected="expectedNoWhitespace" id="nowhitespace" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="result" expected="expectedWhitespace" id="whitespace" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodenotationnodeattributes.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodenotationnodeattributes"> |
| <metadata> |
| <title>nodeNotationNodeAttributes</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method invoked on a Notation |
| Node returns null. |
| Retrieve the Notation declaration inside the DocumentType |
| node and invoke the "getAttributes()" method on the |
| Notation Node. It should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notationNode" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notations"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem obj="notations" name='"notation1"' var="notationNode"/> |
| <assertNotNull actual="notationNode" id="notationNotNull"/> |
| <attributes obj="notationNode" var="attrList"/> |
| <assertNull actual="attrList" id="nodeNotationNodeAttributesAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodenotationnodename.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodenotationnodename"> |
| <metadata> |
| <title>nodeNotationNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| Notation Node is the name of the notation. |
| Retrieve the Notation declaration inside the |
| DocumentType node and check the string returned |
| by the "getNodeName()" method. It should be equal to |
| "notation1". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notationNode" type="Node"/> |
| <var name="notationName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notations"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem obj="notations" name='"notation1"' var="notationNode"/> |
| <assertNotNull actual="notationNode" id="notationNotNull"/> |
| <nodeName obj="notationNode" var="notationName"/> |
| <assertEquals actual="notationName" expected='"notation1"' id="nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodenotationnodetype.xml.notimpl |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodenotationnodetype"> |
| <metadata> |
| <title>nodeNotationNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for an Notation Node |
| returns the constant value 12. |
| Retrieve the Notation declaration in the DocumentType |
| node and invoke the "getNodeType()" method. The method |
| should return 12. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notationNode" type="Notation"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notations"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem obj="notations" var="notationNode" name='"notation1"'/> |
| <assertNotNull actual="notationNode" id="notationNotNull"/> |
| <nodeType obj="notationNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="12" id="nodeNotationNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodenotationnodevalue.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodenotationnodevalue"> |
| <metadata> |
| <title>nodeNotationNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| Notation Node is null. |
| Retrieve the Notation declaration inside the |
| DocumentType node and check the string returned |
| by the "getNodeValue()" method. It should be equal to |
| null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notationNode" type="Node"/> |
| <var name="notationValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notations"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem obj="notations" name=""notation1"" var="notationNode"/> |
| <assertNotNull actual="notationNode" id="notationNotNull"/> |
| <nodeValue obj="notationNode" var="notationValue"/> |
| <assertNull actual="notationValue" id="nodeValue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeparentnode.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeparentnode"> |
| <metadata> |
| <title>nodeParentNode</title> |
| <creator>NIST</creator> |
| <description> |
| The "getParentNode()" method returns the parent |
| of this node. |
| Retrieve the second employee and invoke the |
| "getParentNode()" method on this node. It should |
| be set to "staff". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1060184317"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=251"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="parentNode" type="Node"/> |
| <var name="parentName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <parentNode interface="Node" obj="employeeNode" var="parentNode"/> |
| <nodeName obj="parentNode" var="parentName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertEquals actual="parentName" expected='"svg"' id="svgTagName" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="parentName" expected='"staff"' id="nodeParentNodeAssert1" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeparentnodenull.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeparentnodenull"> |
| <metadata> |
| <title>nodeParentNodeNull</title> |
| <creator>NIST</creator> |
| <description> |
| The "getParentNode()" method invoked on a node that has |
| just been created and not yet added to the tree is null. |
| Create a new "employee" Element node using the |
| "createElement(name)" method from the Document interface. |
| Since this new node has not yet been added to the tree, |
| the "getParentNode()" method will return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1060184317"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="createdNode" type="Element"/> |
| <var name="parentNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createElement obj="doc" tagName='"employee"' var="createdNode"/> |
| <parentNode interface="Node" obj="createdNode" var="parentNode"/> |
| <assertNull actual="parentNode" id="parentNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeprocessinginstructionnodeattributes.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeprocessinginstructionnodeattributes"> |
| <metadata> |
| <title>nodeProcessingInstructionNodeAttributes</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method invoked on a Processing |
| Instruction Node returns null. |
| Retrieve the Processing Instruction node and invoke |
| the "getAttributes()" method. It should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="testList" type="NodeList"/> |
| <var name="piNode" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="testList"/> |
| <item interface="NodeList" obj="testList" index="0" var="piNode"/> |
| <attributes obj="piNode" var="attrList"/> |
| <assertNull actual="attrList" id="nodeProcessingInstructionNodeAttrAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeprocessinginstructionnodename.xml.kfail |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeprocessinginstructionnodename"> |
| <metadata> |
| <title>nodeProcessingInstructionNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| Processing Instruction Node is the target. |
| Retrieve the Processing Instruction Node in the XML file |
| and check the string returned by the "getNodeName()" |
| method. It should be equal to "XML-STYLE". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="testList" type="NodeList"/> |
| <var name="piNode" type="Node"/> |
| <var name="piName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="testList"/> |
| <item interface="NodeList" obj="testList" index="0" var="piNode"/> |
| <nodeName obj="piNode" var="piName"/> |
| <assertEquals actual="piName" expected=""TEST-STYLE"" id="nodeProcessingInstructionNodeNameAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeprocessinginstructionnodetype.xml.kfail |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeprocessinginstructionnodetype"> |
| <metadata> |
| <title>nodeProcessingInstructionNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for a Processing Instruction |
| node returns the constant value 7. |
| Retrieve a NodeList of child elements from the document. |
| Retrieve the first child and invoke the "getNodeType()" |
| method. The method should return 7. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="testList" type="NodeList"/> |
| <var name="piNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="testList"/> |
| <item interface="NodeList" obj="testList" var="piNode" index="0"/> |
| <nodeType obj="piNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="7" id="nodeProcessingInstructionNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeprocessinginstructionnodevalue.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeprocessinginstructionnodevalue"> |
| <metadata> |
| <title>nodeProcessingInstructionNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| Processing Instruction Node is the content of the |
| Processing Instruction(exclude the target). |
| Retrieve the Processing Instruction node in the XML file |
| and check the string returned by the "getNodeValue()" |
| method. It should be equal to "PIDATA". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="testList" type="NodeList"/> |
| <var name="piNode" type="Node"/> |
| <var name="piValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="testList"/> |
| <item interface="NodeList" obj="testList" index="0" var="piNode"/> |
| <nodeValue obj="piNode" var="piValue"/> |
| <assertEquals actual="piValue" expected=""PIDATA"" id="value" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodeprocessinginstructionsetnodevalue.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodeprocessinginstructionsetnodevalue"> |
| <metadata> |
| <title>nodeProcessingInstructionSetNodeValue</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Setting the nodeValue should change the value returned by |
| nodeValue and ProcessingInstruction.getData. |
| </description> |
| <date qualifier="created">2001-10-21</date> |
| <!-- Node.nodeValue --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <!-- ProcessingInstruction interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1004215813"/> |
| <!--data attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-837822393"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=181"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="testList" type="NodeList"/> |
| <var name="piNode" type="Node"/> |
| <var name="piValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <childNodes obj="doc" var="testList"/> |
| <item interface="NodeList" obj="testList" index="0" var="piNode"/> |
| <nodeValue obj="piNode" value='"Something different"'/> |
| <nodeValue obj="piNode" var="piValue"/> |
| <assertEquals actual="piValue" expected='"Something different"' id="nodeValue" ignoreCase="false"/> |
| <data interface="ProcessingInstruction" obj="piNode" var="piValue"/> |
| <assertEquals actual="piValue" expected='"Something different"' id="data" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/noderemovechild.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="noderemovechild"> |
| <metadata> |
| <title>nodeRemoveChild</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeChild(oldChild)" method removes the child node |
| indicated by "oldChild" from the list of children and |
| returns it. |
| Remove the first employee by invoking the |
| "removeChild(oldChild)" method an checking the |
| node returned by the "getParentNode()" method. It |
| should be set to null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="childToRemove" type="Node"/> |
| <var name="removedChild" type="Node"/> |
| <var name="parentNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <childNodes obj="rootNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="1" var="childToRemove"/> |
| <removeChild obj="rootNode" var="removedChild" oldChild="childToRemove"/> |
| <parentNode interface="Node" obj="removedChild" var="parentNode"/> |
| <assertNull actual="parentNode" id="nodeRemoveChildAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/noderemovechildgetnodename.xml.int-broken |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="noderemovechildgetnodename"> |
| <metadata> |
| <title>nodeRemoveChildGetNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| Remove the first child of the second employee |
| and check the NodeName returned by the |
| "removeChild(oldChild)" method. The returned node |
| should have a NodeName equal to "#text" or employeeId depending on whitespace. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="removedChild" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <length var="length" obj="childList" interface="NodeList"/> |
| <item interface="NodeList" obj="childList" index="0" var="oldChild"/> |
| <removeChild obj="employeeNode" oldChild="oldChild" var="removedChild"/> |
| <nodeName obj="removedChild" var="childName"/> |
| <if><equals actual="length" expected="6" ignoreCase="false"/> |
| <assertEquals actual="childName" expected='"employeeId"' id="nowhitespace" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="childName" expected='"#text"' id="whitespace" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/noderemovechildnode.xml.int-broken |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="noderemovechildnode"> |
| <metadata> |
| <title>nodeRemoveChildNode</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the second employee and remove its first child. |
| After the removal, the second employee should have five or twelve |
| children and the first child should now be the child |
| that used to be at the second position in the list. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="length" type="int"/> |
| <var name="removedChild" type="Node"/> |
| <var name="removedName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="0" var="oldChild"/> |
| <removeChild var="removedChild" obj="employeeNode" oldChild="oldChild"/> |
| <nodeName obj="removedChild" var="removedName"/> |
| <item interface="NodeList" obj="childList" index="0" var="child"/> |
| <nodeName obj="child" var="childName"/> |
| <length interface="NodeList" obj="childList" var="length"/> |
| <if><equals actual="length" expected="5" ignoreCase="false"/> |
| <assertEquals actual="removedName" expected='"employeeId"' ignoreCase="false" id="removedNameNoWhitespace"/> |
| <assertEquals actual="childName" expected='"name"' ignoreCase="false" id="childNameNoWhitespace"/> |
| <else> |
| <assertEquals actual="removedName" expected='"#text"' ignoreCase="false" id="removedName"/> |
| <assertEquals actual="childName" expected='"employeeId"' ignoreCase="false" id="childName"/> |
| <assertEquals actual="length" expected="12" ignoreCase="false" id="length"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/noderemovechildnomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="noderemovechildnomodificationallowederr"> |
| <metadata> |
| <title>nodeRemoveChildNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeChild(oldChild)" method causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the FIRST item |
| from the entity reference and execute the "removeChild(oldChild)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1734834066')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entRef" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="removedNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item obj="genderList" index="2" var="genderNode" interface="NodeList"/> |
| <firstChild interface="Node" var="entRef" obj="genderNode"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <nodeType var="nodeType" obj="entRef"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild var="removedNode" obj="entRef" oldChild="entElement"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/noderemovechildnomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="noderemovechildnomodificationallowederrEE"> |
| <metadata> |
| <title>nodeRemoveChildNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "removeChild(oldChild)" method causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Create an entity reference and execute the "removeChild(oldChild)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-21</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1734834066')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/noderemovechildnomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="Node"/> |
| <var name="entText" type="Node"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <firstChild interface="Node" var="entText" obj="entRef"/> |
| <assertNotNull actual="entText" id="entTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild var="removedNode" obj="entRef" oldChild="entText"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/noderemovechildoldchildnonexistent.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="noderemovechildoldchildnonexistent"> |
| <metadata> |
| <title>nodeRemoveChildOldChildNonexistent</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeChild(oldChild)" method raises a |
| NOT_FOUND_ERR DOMException if the old child is |
| not a child of this node. |
| Retrieve the second employee and attempt to remove a |
| node that is not one of its children. An attempt to |
| remove such a node should raise the desired exception. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-1734834066')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="oldChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="removedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createElement obj="doc" tagName=""oldChild"" var="oldChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild var="removedChild" obj="elementNode" oldChild="oldChild"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodereplacechild.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodereplacechild"> |
| <metadata> |
| <title>nodeReplaceChild</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method replaces |
| the node "oldChild" with the node "newChild". |
| Replace the first element of the second employee with |
| a newly created Element node. Check the first position |
| after the replacement operation is completed. The new |
| Element should be "newChild". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="replacedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="0" var="oldChild"/> |
| <createElement obj="doc" tagName=""newChild"" var="newChild"/> |
| <replaceChild var="replacedNode" obj="employeeNode" newChild="newChild" oldChild="oldChild"/> |
| <item interface="NodeList" obj="childList" index="0" var="child"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected=""newChild"" id="nodeReplaceChildAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodereplacechildinvalidnodetype.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodereplacechildinvalidnodetype"> |
| <metadata> |
| <title>nodeReplaceChildInvalidNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if this node is of |
| a type that does not allow children of the type "newChild" |
| to be inserted. |
| Retrieve the root node and attempt to replace |
| one of its children with a newly created Attr node. |
| An Element node cannot have children of the "Attr" |
| type, therefore the desired exception should be raised. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Element"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="replacedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <createAttribute obj="doc" name=""newAttribute"" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="oldChild"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <replaceChild var="replacedChild" obj="rootNode" newChild="newChild" oldChild="oldChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodereplacechildnewchilddiffdocument.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodereplacechildnewchilddiffdocument"> |
| <metadata> |
| <title>nodeReplaceChildNewChildDiffDocument</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method raises a |
| WRONG_DOCUMENT_ERR DOMException if the "newChild" was |
| created from a different document than the one that |
| created this node. |
| Retrieve the second employee and attempt to replace one |
| of its children with a node created from a different |
| document. An attempt to make such a replacement |
| should raise the desired exception. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="oldChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="replacedChild" type="Node"/> |
| <load var="doc1" href="staff" willBeModified="false"/> |
| <load var="doc2" href="staff" willBeModified="true"/> |
| <createElement obj="doc1" tagName=""newChild"" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc2" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <firstChild obj="elementNode" var="oldChild" interface="Node"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <replaceChild var="replacedChild" obj="elementNode" newChild="newChild" oldChild="oldChild"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodereplacechildnewchildexists.xml.int-broken |
|---|
| 0,0 → 1,84 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodereplacechildnewchildexists"> |
| <metadata> |
| <title>nodeReplaceChildNewChildExists</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the second employee and replace its TWELFTH |
| child(address) with its SECOND child(employeeId). After the |
| replacement the second child should now be the one that used |
| to be at the third position and the TWELFTH child should be the |
| one that used to be at the SECOND position. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node" isNull="true"/> |
| <var name="newChild" type="Node" isNull="true"/> |
| <var name="childName" type="DOMString"/> |
| <var name="childNode" type="Node"/> |
| <var name="length" type="int"/> |
| <var name="actual" type="List"/> |
| <var name="expected" type="List"/> |
| <var name="expectedWithoutWhitespace" type="List"> |
| <member>"name"</member> |
| <member>"position"</member> |
| <member>"salary"</member> |
| <member>"gender"</member> |
| <member>"employeeId"</member> |
| </var> |
| <var name="expectedWithWhitespace" type="List"> |
| <member>"#text"</member> |
| <member>"#text"</member> |
| <member>"name"</member> |
| <member>"#text"</member> |
| <member>"position"</member> |
| <member>"#text"</member> |
| <member>"salary"</member> |
| <member>"#text"</member> |
| <member>"gender"</member> |
| <member>"#text"</member> |
| <member>"employeeId"</member> |
| <member>"#text"</member> |
| </var> |
| <var name="replacedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <length var="length" obj="childList" interface="NodeList"/> |
| <if><equals actual="length" expected="13" ignoreCase="false"/> |
| <item interface="NodeList" obj="childList" index="1" var="newChild"/> |
| <item interface="NodeList" obj="childList" index="11" var="oldChild"/> |
| <assign var="expected" value="expectedWithWhitespace"/> |
| <else> |
| <item interface="NodeList" obj="childList" index="0" var="newChild"/> |
| <item interface="NodeList" obj="childList" index="5" var="oldChild"/> |
| <assign var="expected" value="expectedWithoutWhitespace"/> |
| </else> |
| </if> |
| <replaceChild var="replacedChild" obj="employeeNode" newChild="newChild" oldChild="oldChild"/> |
| <assertSame actual="replacedChild" expected="oldChild" id="return_value_same"/> |
| <for-each collection="childList" member="childNode"> |
| <nodeName var="childName" obj="childNode"/> |
| <append collection="actual" item="childName"/> |
| </for-each> |
| <assertEquals actual="actual" expected="expected" id="childNames" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodereplacechildnodeancestor.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodereplacechildnodeancestor"> |
| <metadata> |
| <title>nodeReplaceChildNodeAncestor</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method raises a |
| HIERARCHY_REQUEST_ERR DOMException if the node to put |
| in is one of this node's ancestors. |
| Retrieve the second employee and attempt to replace |
| one of its children with an ancestor node(root node). |
| An attempt to make such a replacement should raise the |
| desired exception. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="replacedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <documentElement obj="doc" var="newChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <item interface="NodeList" obj="childList" index="0" var="oldChild"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <replaceChild var="replacedNode" obj="employeeNode" newChild="newChild" oldChild="oldChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodereplacechildnodename.xml.int-broken |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodereplacechildnodename"> |
| <metadata> |
| <title>nodeReplaceChildNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| Replace the second Element of the second employee with |
| a newly created node Element and check the NodeName |
| returned by the "replaceChild(newChild,oldChild)" |
| method. The returned node should have a NodeName equal |
| to "employeeId". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="oldChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="replacedNode" type="Node"/> |
| <var name="length" type="int"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <childNodes obj="employeeNode" var="childList"/> |
| <length var="length" obj="childList" interface="NodeList"/> |
| <item interface="NodeList" obj="childList" index="1" var="oldChild"/> |
| <createElement obj="doc" tagName=""newChild"" var="newChild"/> |
| <replaceChild obj="employeeNode" newChild="newChild" oldChild="oldChild" var="replacedNode"/> |
| <nodeName obj="replacedNode" var="childName"/> |
| <if><equals actual="length" expected="6" ignoreCase="false"/> |
| <assertEquals actual="childName" expected='"name"' id="nowhitespace" ignoreCase="false"/> |
| <else> |
| <assertEquals actual="childName" expected='"employeeId"' id="whitespace" ignoreCase="false"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodereplacechildnomodificationallowederr.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodereplacechildnomodificationallowederr"> |
| <metadata> |
| <title>nodeReplaceChildNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the FIRST item |
| from the entity reference and execute the "replaceChild(newChild,oldChild)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2001-08-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entRef" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="createdNode" type="Node"/> |
| <var name="replacedChild" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item obj="genderList" index="2" var="genderNode" interface="NodeList"/> |
| <firstChild interface="Node" var="entRef" obj="genderNode"/> |
| <nodeType var="nodeType" obj="entRef"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <createElement obj="doc" tagName=""newChild"" var="createdNode"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild var="replacedChild" obj="entRef" newChild="createdNode" oldChild="entElement"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodereplacechildnomodificationallowederrEE.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodereplacechildnomodificationallowederrEE"> |
| <metadata> |
| <title>nodeReplaceChildNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Create an entity reference execute the "replaceChild(newChild,oldChild)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/nodereplacechildnomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="Node"/> |
| <var name="entText" type="Node"/> |
| <var name="createdNode" type="Node"/> |
| <var name="replacedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <firstChild interface="Node" var="entText" obj="entRef"/> |
| <createElement obj="doc" tagName=""newChild"" var="createdNode"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild var="replacedChild" obj="entRef" newChild="createdNode" oldChild="entText"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodereplacechildoldchildnonexistent.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodereplacechildoldchildnonexistent"> |
| <metadata> |
| <title>nodeReplaceChildOldChildNonexistent</title> |
| <creator>NIST</creator> |
| <description> |
| The "replaceChild(newChild,oldChild)" method raises a |
| NOT_FOUND_ERR DOMException if the old child is |
| not a child of this node. |
| Retrieve the second employee and attempt to replace a |
| node that is not one of its children. An attempt to |
| replace such a node should raise the desired exception. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-785887307')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-785887307"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="oldChild" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementNode" type="Node"/> |
| <var name="replacedNode" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createElement obj="doc" tagName=""newChild"" var="newChild"/> |
| <createElement obj="doc" tagName=""oldChild"" var="oldChild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="elementNode"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <replaceChild var="replacedNode" obj="elementNode" newChild="newChild" oldChild="oldChild"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodesetnodevaluenomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodesetnodevaluenomodificationallowederr"> |
| <metadata> |
| <title>nodeSetNodeValueNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "setNodeValue(nodeValue)" method causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the SECOND item |
| from the entity reference and execute the "setNodeValue(nodeValue)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-F68D080')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <var name="entElementText" type="CharacterData"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""gender"" var="genderList"/> |
| <item obj="genderList" index="2" var="genderNode" interface="NodeList"/> |
| <firstChild interface="Node" var="entRef" obj="genderNode"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <nodeType var="nodeType" obj="entRef"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <firstChild interface="Node" var="entElementText" obj="entElement"/> |
| <assertNotNull actual="entElementText" id="entElementTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <nodeValue obj="entElementText" value='"newValue"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodesetnodevaluenomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodesetnodevaluenomodificationallowederrEE"> |
| <metadata> |
| <title>nodeSetNodeValueNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create an entity reference and execute the "setNodeValue(nodeValue)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-F68D080')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/nodesetnodevaluenomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entText" type="CharacterData"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent3"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <firstChild interface="Node" var="entText" obj="entRef"/> |
| <assertNotNull actual="entText" id="entTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <nodeValue obj="entText" value='"newValue"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodetextnodeattribute.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodetextnodeattribute"> |
| <metadata> |
| <title>nodeTextNodeAttribute</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributes()" method invoked on a Text |
| Node returns null. |
| Retrieve the Text node from the last child of the |
| first employee and invoke the "getAttributes()" method |
| on the Text Node. It should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--attributes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-84CF096"/> |
| <!-- Text interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1312295772"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="attrList" type="NamedNodeMap"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <firstChild interface="Node" obj="testAddr" var="textNode"/> |
| <attributes obj="textNode" var="attrList"/> |
| <assertNull actual="attrList" id="nodeTextNodeAttributesAssert1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodetextnodename.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodetextnodename"> |
| <metadata> |
| <title>nodeTextNodeName</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeName()" method for a |
| Text Node is "#text". |
| Retrieve the Text Node from the last child of the |
| first employee and check the string returned |
| by the "getNodeName()" method. It should be equal to |
| "#text". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="textNode" type="Node"/> |
| <var name="textName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <firstChild interface="Node" obj="testAddr" var="textNode"/> |
| <nodeName obj="textNode" var="textName"/> |
| <assertEquals actual="textName" expected=""#text"" id="nodeTextNodeNameAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodetextnodetype.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodetextnodetype"> |
| <metadata> |
| <title>nodeTextNodeType</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNodeType()" method for a Text Node |
| returns the constant value 3. |
| Retrieve the Text node from the last child of |
| the first employee and invoke the "getNodeType()" |
| method. The method should return 3. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-111237558"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="textNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <firstChild interface="Node" obj="testAddr" var="textNode"/> |
| <nodeType obj="textNode" var="nodeType"/> |
| <assertEquals actual="nodeType" expected="3" id="nodeTextNodeTypeAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodetextnodevalue.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodetextnodevalue"> |
| <metadata> |
| <title>nodeTextNodeValue</title> |
| <creator>NIST</creator> |
| <description> |
| The string returned by the "getNodeValue()" method for a |
| Text Node is the content of the Text node. |
| Retrieve the Text node from the last child of the first |
| employee and check the string returned by the |
| "getNodeValue()" method. It should be equal to |
| "1230 North Ave. Dallas, Texas 98551". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="textNode" type="Node"/> |
| <var name="textValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <firstChild interface="Node" obj="testAddr" var="textNode"/> |
| <nodeValue obj="textNode" var="textValue"/> |
| <assertEquals actual="textValue" expected=""1230 North Ave. Dallas, Texas 98551"" id="nodeTextNodeValueAssert1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodevalue01.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodevalue01"> |
| <metadata> |
| <title>nodevalue01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An element is created, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2001-10-24</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Element"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createElement obj="doc" var="newNode" tagName=""address""/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodevalue02.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodevalue02"> |
| <metadata> |
| <title>nodevalue02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An comment is created, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2001-10-24</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1728279322"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createComment obj="doc" var="newNode" data=""This is a new Comment node""/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertEquals actual="newValue" expected='"This is a new Comment node"' ignoreCase="false" id="initial"/> |
| <!-- attempt to change the value --> |
| <nodeValue obj="newNode" value='"This should have an effect"'/> |
| <!-- retrieve the value --> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertEquals actual="newValue" expected='"This should have an effect"' id="afterChange" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodevalue03.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodevalue03"> |
| <metadata> |
| <title>nodevalue03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An entity reference is created, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2001-10-24</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-11C98490"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference obj="doc" var="newNode" name='"ent1"'/> |
| <assertNotNull actual="newNode" id="createdEntRefNotNull"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodevalue04.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodevalue04"> |
| <metadata> |
| <title>nodevalue04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An document type accessed, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2001-10-24</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A31"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <doctype obj="doc" var="newNode"/> |
| <assertNotNull actual="newNode" id="docTypeNotNull"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodevalue05.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodevalue05"> |
| <metadata> |
| <title>nodevalue05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| A document fragment is created, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2001-10-24</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A3"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="newNode"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodevalue06.xml |
|---|
| 0,0 → 1,35 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodevalue06"> |
| <metadata> |
| <title>nodevalue06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An document is accessed, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2001-10-24</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#i-Document"/> |
| </metadata> |
| <var name="newNode" type="Document"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="newNode" href="staff" willBeModified="true"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodevalue07.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodevalue07"> |
| <metadata> |
| <title>nodevalue07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An Entity is accessed, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2001-10-24</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-527DCFF2"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <var name="nodeMap" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities obj="docType" var="nodeMap"/> |
| <assertNotNull actual="nodeMap" id="entitiesNotNull"/> |
| <getNamedItem obj="nodeMap" name='"ent1"' var="newNode"/> |
| <assertNotNull actual="newNode" id="entityNotNull"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodevalue08.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodevalue08"> |
| <metadata> |
| <title>nodevalue08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An notation is accessed, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2001-10-24</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-5431D1B9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <var name="nodeMap" type="NamedNodeMap"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="nodeMap"/> |
| <assertNotNull actual="nodeMap" id="notationsNotNull"/> |
| <getNamedItem obj="nodeMap" name='"notation1"' var="newNode"/> |
| <assertNotNull actual="newNode" id="notationNotNull"/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="initiallyNull"/> |
| <!-- attempt to change the value and make sure that it stays null --> |
| <nodeValue obj="newNode" value='"This should have no effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertNull actual="newValue" id="nullAfterAttemptedChange"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/nodevalue09.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="nodevalue09"> |
| <metadata> |
| <title>nodevalue09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An processing instruction is created, setNodeValue is called with a non-null argument, but getNodeValue |
| should still return null. |
| </description> |
| <date qualifier="created">2001-10-24</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1004215813"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newNode" type="Node"/> |
| <var name="newValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createProcessingInstruction var="newNode" obj="doc" target='"TARGET"' data='"DATA"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertEquals actual="newValue" expected='"DATA"' ignoreCase="false" id="initial"/> |
| <nodeValue obj="newNode" value='"This should have an effect"'/> |
| <nodeValue obj="newNode" var="newValue"/> |
| <assertEquals actual="newValue" expected='"This should have an effect"' ignoreCase="false" id="after"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/notationgetnotationname.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="notationgetnotationname"> |
| <metadata> |
| <title>notationGetNotationName</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the notation named "notation1" and access its |
| name by invoking the "getNodeName()" method inherited |
| from the Node interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--nodeName attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D095"/> |
| <!--Notation interface --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-5431D1B9"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notationNode" type="Notation"/> |
| <var name="notationName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notations"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem obj="notations" var="notationNode" name='"notation1"'/> |
| <nodeName obj="notationNode" var="notationName"/> |
| <assertEquals actual="notationName" expected='"notation1"' id="notationGetNotationNameAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/notationgetpublicid.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="notationgetpublicid"> |
| <metadata> |
| <title>notationGetPublicId</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the notation named "notation1" and access its |
| public identifier. The string "notation1File" should be |
| returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-54F2B4D0"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notationNode" type="Notation"/> |
| <var name="publicId" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notations"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem obj="notations" var="notationNode" name=""notation1""/> |
| <publicId interface="Notation" obj="notationNode" var="publicId"/> |
| <assertEquals actual="publicId" expected='"notation1File"' id="publicId" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/notationgetpublicidnull.xml.notimpl |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="notationgetpublicidnull"> |
| <metadata> |
| <title>notationGetPublicIdNull</title> |
| <creator>NIST</creator> |
| <description> |
| The "getPublicId()" method of a Notation node contains |
| the public identifier associated with the notation, if |
| one was not specified a null value should be returned. |
| Retrieve the notation named "notation2" and access its |
| public identifier. Since a public identifier was not |
| specified for this notation, the "getPublicId()" method |
| should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-54F2B4D0"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notationNode" type="Notation"/> |
| <var name="publicId" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notations"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem obj="notations" var="notationNode" name='"notation2"'/> |
| <publicId interface="Notation" obj="notationNode" var="publicId"/> |
| <assertNull actual="publicId" id="publicId"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/notationgetsystemid.xml.notimpl |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="notationgetsystemid"> |
| <metadata> |
| <title>notationGetSystemId</title> |
| <creator>NIST</creator> |
| <description> |
| The "getSystemId()" method of a Notation node contains |
| the system identifier associated with the notation, if |
| one was specified. |
| Retrieve the notation named "notation2" and access its |
| system identifier. The string "notation2File" should be |
| returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E8AAB1D0"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notationNode" type="Notation"/> |
| <var name="systemId" type="DOMString"/> |
| <var name="index" type="int"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notations"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem obj="notations" var="notationNode" name='"notation2"'/> |
| <systemId interface="Notation" obj="notationNode" var="systemId"/> |
| <assertURIEquals actual="systemId" file='"notation2File"' id="uriEquals"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/notationgetsystemidnull.xml.notimpl |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="notationgetsystemidnull"> |
| <metadata> |
| <title>notationGetSystemIdNull</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the notation named "notation1" and access its |
| system identifier. Since a system identifier was not |
| specified for this notation, the "getSystemId()" method |
| should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-E8AAB1D0"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notationNode" type="Notation"/> |
| <var name="systemId" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations obj="docType" var="notations"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem obj="notations" var="notationNode" name='"notation1"'/> |
| <systemId interface="Notation" obj="notationNode" var="systemId"/> |
| <assertNull actual="systemId" id="systemId"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/processinginstructiongetdata.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="processinginstructiongetdata"> |
| <metadata> |
| <title>processinginstructionGetData</title> |
| <creator>NIST</creator> |
| <description> |
| The "getData()" method returns the content of the |
| processing instruction. It starts at the first non |
| white character following the target and ends at the |
| character immediately preceding the "?>". |
| Retrieve the ProcessingInstruction node located |
| immediately after the prolog. Create a nodelist of the |
| child nodes of this document. Invoke the "getData()" |
| method on the first child in the list. This should |
| return the content of the ProcessingInstruction. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-837822393"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="childNodes" type="NodeList"/> |
| <var name="piNode" type="ProcessingInstruction"/> |
| <var name="data" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="childNodes"/> |
| <item interface="NodeList" obj="childNodes" var="piNode" index="0"/> |
| <data interface="ProcessingInstruction" obj="piNode" var="data"/> |
| <assertEquals actual="data" expected=""PIDATA"" id="processinginstructionGetTargetAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/processinginstructiongettarget.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="processinginstructiongettarget"> |
| <metadata> |
| <title>processinginstructionGetTarget</title> |
| <creator>NIST</creator> |
| <description> |
| The "getTarget()" method returns the target of the |
| processing instruction. It is the first token following |
| the markup that begins the processing instruction. |
| Retrieve the ProcessingInstruction node located |
| immediately after the prolog. Create a nodelist of the |
| child nodes of this document. Invoke the "getTarget()" |
| method on the first child in the list. This should |
| return the target of the ProcessingInstruction. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1478689192"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="childNodes" type="NodeList"/> |
| <var name="piNode" type="ProcessingInstruction"/> |
| <var name="target" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <childNodes obj="doc" var="childNodes"/> |
| <item interface="NodeList" obj="childNodes" var="piNode" index="0"/> |
| <target obj="piNode" var="target" interface="ProcessingInstruction"/> |
| <assertEquals actual="target" expected=""TEST-STYLE"" id="processinginstructionGetTargetAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/processinginstructionsetdatanomodificationallowederr.xml.notimpl |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="processinginstructionsetdatanomodificationallowederr"> |
| <metadata> |
| <title>processinginstructionSetDataNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "setData(data)" method for a processing instruction causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Try to remove the "domestic" attribute |
| from the entity reference by executing the "setData(data)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-837822393"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-837822393')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-837822393"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="entRef" type="Node"/> |
| <var name="piNode" type="ProcessingInstruction"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <firstChild interface="Node" var="entRef" obj="gender"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <lastChild interface="Node" var="piNode" obj="entRef"/> |
| <assertNotNull actual="piNode" id="piNodeNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <data interface="ProcessingInstruction" obj="piNode" value=""newData""/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/processinginstructionsetdatanomodificationallowederrEE.xml.notimpl |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="processinginstructionsetdatanomodificationallowederrEE"> |
| <metadata> |
| <title>processinginstructionSetDataNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "setData(data)" method for a processing instruction causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Create an ent4 entity reference and add to document of the THIRD "gender" element. The elements |
| content is an entity reference. Try to remove the "domestic" attribute |
| from the entity reference by executing the "setData(data)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-21</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-837822393"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-837822393')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-837822393"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/processinginstructionsetdatanomodificationallowederr.xml"/> |
| <!-- bug report on earlier version --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Apr/0053.html"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="entRef" type="Node"/> |
| <var name="piNode" type="ProcessingInstruction"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <appendChild var="appendedChild" obj="gender" newChild="entRef"/> |
| <lastChild interface="Node" var="entRef" obj="gender"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <lastChild interface="Node" var="piNode" obj="entRef"/> |
| <assertNotNull actual="piNode" id="piNodeNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <data interface="ProcessingInstruction" obj="piNode" value='"newData"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/textindexsizeerrnegativeoffset.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="textindexsizeerrnegativeoffset"> |
| <metadata> |
| <title>textIndexSizeErrNegativeOffset</title> |
| <creator>NIST</creator> |
| <description> |
| The "splitText(offset)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset is |
| negative. |
| Retrieve the textual data from the second child of the |
| third employee and invoke the "splitText(offset)" method. |
| The desired exception should be raised since the offset |
| is a negative number. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-38853C1D')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="signed" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""name""/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="textNode"/> |
| <assertDOMException id="throws_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <splitText obj="textNode" var="splitNode" offset="-69"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/textindexsizeerroffsetoutofbounds.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="textindexsizeerroffsetoutofbounds"> |
| <metadata> |
| <title>textIndexSizeErrOffsetOutOfBounds</title> |
| <creator>NIST</creator> |
| <description> |
| The "splitText(offset)" method raises an |
| INDEX_SIZE_ERR DOMException if the specified offset is |
| greater than the number of characters in the Text node. |
| Retrieve the textual data from the second child of the |
| third employee and invoke the "splitText(offset)" method. |
| The desired exception should be raised since the offset |
| is a greater than the number of characters in the Text |
| node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-38853C1D')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=249"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""name""/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="textNode"/> |
| <assertDOMException id="throw_INDEX_SIZE_ERR"> |
| <INDEX_SIZE_ERR> |
| <splitText obj="textNode" var="splitNode" offset="300"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/textparseintolistofelements.xml.kfail |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="textparseintolistofelements"> |
| <metadata> |
| <title>textParseIntoListOfElements</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the textual data from the last child of the |
| second employee. That node is composed of two |
| EntityReference nodes and two Text nodes. After |
| the content node is parsed, the "address" Element |
| should contain four children with each one of the |
| EntityReferences containing one child. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <!--childNodes attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1451460987"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-11C98490"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-745549614"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="addressNode" type="Node"/> |
| <var name="childList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="length" type="int"/> |
| <var name="value" type="DOMString"/> |
| <var name="grandChild" type="Node"/> |
| <var name="result" type="List"/> |
| <var name="expectedNormal" type="List"> |
| <member>"1900 Dallas Road"</member> |
| <member>" Dallas, "</member> |
| <member>"Texas"</member> |
| <member>"\n 98554"</member> |
| </var> |
| <var name="expectedExpanded" type="List"> |
| <member>"1900 Dallas Road Dallas, Texas\n 98554"</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="addressNode" index="1"/> |
| <childNodes obj="addressNode" var="childList"/> |
| <length var="length" obj="childList" interface="NodeList"/> |
| <for-each collection="childList" member="child"> |
| <nodeValue obj="child" var="value"/> |
| <if><isNull obj="value"/> |
| <firstChild interface="Node" obj="child" var="grandChild"/> |
| <assertNotNull actual="grandChild" id="grandChildNotNull"/> |
| <nodeValue obj="grandChild" var="value"/> |
| <append collection="result" item="value"/> |
| <else> |
| <append collection="result" item="value"/> |
| </else> |
| </if> |
| </for-each> |
| <if><equals actual="length" expected="4" ignoreCase="false"/> |
| <assertEquals actual="result" expected="expectedNormal" ignoreCase="false" id="assertEqNormal"/> |
| <else> |
| <assertEquals actual="result" expected="expectedExpanded" ignoreCase="false" id="assertEqCoalescing"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/textsplittextfour.xml.kfail |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="textsplittextfour"> |
| <metadata> |
| <title>textSplitTextFour</title> |
| <creator>NIST</creator> |
| <description> |
| The "splitText(offset)" method returns the new Text node. |
| Retrieve the textual data from the last child of the |
| first employee and invoke the "splitText(offset)" method. |
| The method should return the new Text node. The offset |
| value used for this test is 30. The "getNodeValue()" |
| method is called to check that the new node now contains |
| the characters at and after position 30. |
| (Starting count at 0) |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="addressNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="addressNode" index="0"/> |
| <firstChild interface="Node" obj="addressNode" var="textNode"/> |
| <splitText obj="textNode" var="splitNode" offset="30"/> |
| <nodeValue obj="splitNode" var="value"/> |
| <assertEquals actual="value" expected=""98551"" id="textSplitTextFourAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/textsplittextnomodificationallowederr.xml.kfail |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="textsplittextnomodificationallowederr"> |
| <metadata> |
| <title>textSplitTextNoModificationAllowedErr</title> |
| <creator>NIST</creator> |
| <description> |
| The "splitText(offset)" method raises a |
| NO_MODIFICATION_ALLOWED_ERR DOMException if the |
| node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the element content of the FIRST |
| Text Node of the entity reference and execute the "splitText(offset)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-38853C1D')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="entRef" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="entElementText" type="Node"/> |
| <var name="splitNode" type="Text"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname='"gender"'/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <firstChild interface="Node" var="entRef" obj="gender"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <nodeType var="nodeType" obj="entRef"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertNotNull actual="entElement" id="entElementNotNull"/> |
| <firstChild interface="Node" var="entElementText" obj="entElement"/> |
| <assertNotNull actual="entElementText" id="entElementTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <splitText var="splitNode" obj="entElementText" offset="2"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/textsplittextnomodificationallowederrEE.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="textsplittextnomodificationallowederrEE"> |
| <metadata> |
| <title>textSplitTextNoModificationAllowedErrEE</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create an ent3 reference and execute the "splitText(offset)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <date qualifier="created">2001-08-21</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-38853C1D')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| <source resource="http://www.w3.org/2001/DOM-Test-Suite/level1/core/textsplittextnomodificationallowederr.xml"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="Node"/> |
| <var name="entText" type="Node"/> |
| <var name="splitNode" type="Text"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent3"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <firstChild interface="Node" var="entText" obj="entRef"/> |
| <assertNotNull actual="entText" id="entTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <splitText var="splitNode" obj="entText" offset="2"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/textsplittextone.xml.kfail |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="textsplittextone"> |
| <metadata> |
| <title>textSplitTextOne</title> |
| <creator>NIST</creator> |
| <description> |
| The "splitText(offset)" method breaks the Text node into |
| two Text nodes at the specified offset keeping each node |
| as siblings in the tree. |
| Retrieve the textual data from the second child of the |
| third employee and invoke the "splitText(offset)" method. |
| The method splits the Text node into two new sibling |
| Text nodes keeping both of them in the tree. This test |
| checks the "nextSibling()" method of the original node |
| to ensure that the two nodes are indeed siblings. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <var name="secondPart" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""name""/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="textNode"/> |
| <splitText obj="textNode" var="splitNode" offset="7"/> |
| <nextSibling interface="Node" obj="textNode" var="secondPart"/> |
| <nodeValue obj="secondPart" var="value"/> |
| <assertEquals actual="value" expected=""Jones"" id="textSplitTextOneAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/textsplittextthree.xml.kfail |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="textsplittextthree"> |
| <metadata> |
| <title>textSplitTextThree</title> |
| <creator>NIST</creator> |
| <description> |
| After the "splitText(offset)" method breaks the Text node |
| into two Text nodes, the new Text node contains all the |
| content at and after the offset point. |
| Retrieve the textual data from the second child of the |
| third employee and invoke the "splitText(offset)" method. |
| The new Text node should contain all the content |
| at and after the offset point. The "getNodeValue()" |
| method is called to check that the new node now contains |
| the characters at and after position seven. |
| (Starting count at 0) |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""name""/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="textNode"/> |
| <splitText obj="textNode" var="splitNode" offset="6"/> |
| <nodeValue obj="splitNode" var="value"/> |
| <assertEquals actual="value" expected="" Jones"" id="textSplitTextThreeAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/textsplittexttwo.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="textsplittexttwo"> |
| <metadata> |
| <title>textSplitTextTwo</title> |
| <creator>NIST</creator> |
| <description> |
| After the "splitText(offset)" method breaks the Text node |
| into two Text nodes, the original node contains all the |
| content up to the offset point. |
| Retrieve the textual data from the second child of the |
| third employee and invoke the "splitText(offset)" method. |
| The original Text node should contain all the content |
| up to the offset point. The "getNodeValue()" method |
| is called to check that the original node now contains |
| the first five characters. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-38853C1D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="splitNode" type="Text"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""name""/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="textNode"/> |
| <splitText obj="textNode" var="splitNode" offset="5"/> |
| <nodeValue obj="textNode" var="value"/> |
| <assertEquals actual="value" expected=""Roger"" id="textSplitTextTwoAssert" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/core/textwithnomarkup.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="textwithnomarkup"> |
| <metadata> |
| <title>textWithNoMarkup</title> |
| <creator>NIST</creator> |
| <description> |
| If there is not any markup inside an Element or Attr node |
| content, then the text is contained in a single object |
| implementing the Text interface that is the only child |
| of the element. |
| Retrieve the textual data from the second child of the |
| third employee. That Text node contains a block of |
| multiple text lines without markup, so they should be |
| treated as a single Text node. The "getNodeValue()" |
| method should contain the combination of the two lines. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1312295772"/> |
| <!--nodeValue attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-F68D080"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nameNode" type="Node"/> |
| <var name="nodeV" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""name""/> |
| <item interface="NodeList" obj="elementList" var="nameNode" index="2"/> |
| <firstChild interface="Node" obj="nameNode" var="nodeV"/> |
| <nodeValue obj="nodeV" var="value"/> |
| <assertEquals actual="value" expected=""Roger\n Jones"" id="textNodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/.cvsignore |
|---|
| 0,0 → 1,2 |
| dom1.dtd |
| dom1.xsd |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/CVS/Entries |
|---|
| 0,0 → 1,642 |
| D/files//// |
| /.cvsignore/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLAnchorElement01.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLAnchorElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLAnchorElement03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAnchorElement04.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /HTMLAnchorElement05.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAnchorElement06.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAnchorElement07.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAnchorElement08.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAnchorElement09.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAnchorElement10.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLAnchorElement11.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLAnchorElement12.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLAnchorElement13.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLAnchorElement14.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLAppletElement01.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /HTMLAppletElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLAppletElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLAppletElement04.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLAppletElement05.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /HTMLAppletElement06.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /HTMLAppletElement07.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLAppletElement08.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLAppletElement09.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLAppletElement10.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAppletElement11.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /HTMLAreaElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLAreaElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLAreaElement03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAreaElement04.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAreaElement05.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAreaElement06.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLAreaElement07.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLAreaElement08.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLBRElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLBaseElement01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLBaseElement02.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLBaseFontElement01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLBaseFontElement02.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLBaseFontElement03.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLBodyElement01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLBodyElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLBodyElement03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLBodyElement04.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLBodyElement05.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLBodyElement06.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLButtonElement01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLButtonElement02.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLButtonElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLButtonElement04.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLButtonElement05.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLButtonElement06.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLButtonElement07.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLButtonElement08.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLCollection01.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /HTMLCollection02.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLCollection03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLCollection04.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLCollection05.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /HTMLCollection06.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLCollection07.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /HTMLCollection08.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLCollection09.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /HTMLCollection10.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLCollection11.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /HTMLCollection12.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /HTMLDirectoryElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLDivElement01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLDlistElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLDocument01.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLDocument02.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLDocument03.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLDocument04.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /HTMLDocument05.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLDocument07.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLDocument08.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /HTMLDocument09.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLDocument10.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLDocument11.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLDocument12.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLDocument13.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLDocument14.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLDocument15.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLDocument16.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLDocument17.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLDocument18.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLDocument19.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLDocument20.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLDocument21.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement05.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement06.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement07.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement08.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement09.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLElement10.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement100.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement101.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement102.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLElement103.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement104.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement105.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement106.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement107.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement108.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement109.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement11.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement110.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement111.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement112.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement113.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement114.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement115.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement116.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement117.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement118.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement119.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement12.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLElement120.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement121.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement122.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement123.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement124.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement125.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement126.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement127.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement128.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement129.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement13.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement130.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement131.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement132.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement133.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement134.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement135.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement136.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement137.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement138.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLElement139.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement14.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement140.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement141.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement142.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement143.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement144.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement145.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement15.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement16.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement17.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement18.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement19.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement20.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement21.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLElement22.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement23.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement24.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement25.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement26.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement27.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement28.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement29.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement30.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement31.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement32.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement33.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement34.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement35.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement36.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement37.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement38.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement39.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement40.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement41.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement42.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLElement43.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement44.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement45.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement46.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement47.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement48.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement49.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement50.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement51.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement52.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement53.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement54.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement55.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLElement56.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement57.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement58.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement59.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement60.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement61.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement62.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement63.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement64.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement65.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement66.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement67.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLElement68.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement69.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement70.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement71.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement72.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement73.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement74.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement75.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement76.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement77.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement78.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement79.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement80.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement81.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement82.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement83.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement84.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement85.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement86.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement87.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement88.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement89.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement90.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLElement91.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement92.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement93.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement94.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLElement95.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement96.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLElement97.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement98.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLElement99.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLFieldSetElement01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLFieldSetElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLFontElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLFontElement02.xml/1.5/Fri Apr 3 02:48:02 2009// |
| /HTMLFontElement03.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLFormElement01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLFormElement02.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLFormElement03.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLFormElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLFormElement05.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLFormElement06.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLFormElement07.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLFormElement08.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLFormElement09.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLFormElement10.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLFrameElement01.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLFrameElement02.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /HTMLFrameElement03.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLFrameElement04.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLFrameElement05.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLFrameElement06.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /HTMLFrameElement07.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLFrameElement08.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /HTMLFrameSetElement01.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLFrameSetElement02.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLHRElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLHRElement02.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLHRElement03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLHRElement04.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLHeadElement01.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLHeadingElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLHeadingElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLHeadingElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLHeadingElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLHeadingElement05.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLHeadingElement06.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLHtmlElement01.xml/1.5/Fri Apr 3 02:48:02 2009// |
| /HTMLIFrameElement01.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLIFrameElement02.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLIFrameElement03.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLIFrameElement04.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /HTMLIFrameElement05.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLIFrameElement06.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLIFrameElement07.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLIFrameElement08.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLIFrameElement09.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /HTMLIFrameElement10.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLImageElement01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLImageElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLImageElement03.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLImageElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLImageElement05.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLImageElement06.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLImageElement07.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLImageElement08.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLImageElement09.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLImageElement10.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLImageElement11.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLImageElement12.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLImageElement14.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLInputElement01.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLInputElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLInputElement03.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLInputElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLInputElement05.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLInputElement06.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLInputElement07.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLInputElement08.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLInputElement09.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLInputElement10.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLInputElement11.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLInputElement12.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLInputElement13.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLInputElement14.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLInputElement15.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLInputElement16.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLInputElement17.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLInputElement18.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLInputElement19.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLInputElement20.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /HTMLInputElement21.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLInputElement22.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLIsIndexElement01.xml/1.6/Fri Apr 3 02:48:02 2009// |
| /HTMLIsIndexElement02.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /HTMLIsIndexElement03.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLLIElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLLIElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLLabelElement01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLLabelElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLLabelElement03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLLabelElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLLegendElement01.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLLegendElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLLegendElement03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLLegendElement04.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLLinkElement01.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /HTMLLinkElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLLinkElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLLinkElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLLinkElement05.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLLinkElement06.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLLinkElement07.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLLinkElement08.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLLinkElement09.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLMapElement01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLMapElement02.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLMenuElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLMetaElement01.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLMetaElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLMetaElement03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLMetaElement04.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLModElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLModElement02.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLModElement03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLModElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLOListElement01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLOListElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLOListElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLObjectElement01.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLObjectElement02.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /HTMLObjectElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLObjectElement04.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLObjectElement05.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLObjectElement06.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLObjectElement07.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLObjectElement08.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLObjectElement09.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLObjectElement10.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLObjectElement11.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLObjectElement12.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLObjectElement13.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLObjectElement14.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLObjectElement15.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLObjectElement16.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLObjectElement17.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLObjectElement18.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLObjectElement19.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLOptGroupElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLOptGroupElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLOptionElement01.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLOptionElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLOptionElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLOptionElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLOptionElement05.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLOptionElement06.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLOptionElement07.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLOptionElement08.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLOptionElement09.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLParagraphElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLParamElement01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLParamElement02.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLParamElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLParamElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLPreElement01.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLQuoteElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLQuoteElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLScriptElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLScriptElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLScriptElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLScriptElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLScriptElement05.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLScriptElement06.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLScriptElement07.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /HTMLSelectElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLSelectElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLSelectElement03.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /HTMLSelectElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLSelectElement05.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLSelectElement06.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLSelectElement07.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLSelectElement08.xml/1.6/Fri Apr 3 02:48:03 2009// |
| /HTMLSelectElement09.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLSelectElement10.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLSelectElement11.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLSelectElement12.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLSelectElement13.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLSelectElement14.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLSelectElement15.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLSelectElement16.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLSelectElement17.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLSelectElement18.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLSelectElement19.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLStyleElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLStyleElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLStyleElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCaptionElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement05.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement06.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLTableCellElement07.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement08.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement09.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement10.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement11.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement12.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement13.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement14.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement15.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement16.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement17.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement18.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement19.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement20.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement21.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLTableCellElement22.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement23.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement24.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement25.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLTableCellElement26.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement27.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableCellElement28.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement29.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableCellElement30.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableColElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableColElement02.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLTableColElement03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableColElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableColElement05.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableColElement06.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableColElement07.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableColElement08.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableColElement09.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableColElement10.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableColElement11.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableColElement12.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableElement03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement04.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLTableElement05.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableElement06.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLTableElement07.xml/1.5/Fri Apr 3 02:48:03 2009// |
| /HTMLTableElement08.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement09.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement10.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableElement11.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement12.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement13.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement14.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement15.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement16.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement17.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement18.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableElement19.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLTableElement20.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLTableElement21.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement22.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLTableElement23.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLTableElement24.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement25.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /HTMLTableElement26.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement27.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement28.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /HTMLTableElement29.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement30.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /HTMLTableElement31.xml/1.7/Fri Apr 3 02:48:02 2009// |
| /HTMLTableElement32.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /HTMLTableElement33.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /HTMLTableRowElement01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableRowElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableRowElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableRowElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableRowElement05.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableRowElement06.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableRowElement07.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLTableRowElement08.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableRowElement09.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableRowElement10.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableRowElement11.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableRowElement12.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLTableRowElement13.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /HTMLTableRowElement14.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLTableSectionElement01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement02.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableSectionElement03.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLTableSectionElement04.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement05.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement06.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement07.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement08.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement09.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /HTMLTableSectionElement10.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableSectionElement11.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTableSectionElement12.xml/1.4/Fri Apr 3 02:48:03 2009// |
| /HTMLTableSectionElement13.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement14.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLTableSectionElement15.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement16.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement17.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement18.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /HTMLTableSectionElement19.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement20.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /HTMLTableSectionElement21.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement22.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLTableSectionElement23.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLTableSectionElement24.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /HTMLTextAreaElement01.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLTextAreaElement02.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLTextAreaElement03.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTextAreaElement04.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTextAreaElement05.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTextAreaElement06.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTextAreaElement07.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTextAreaElement08.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLTextAreaElement09.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTextAreaElement10.xml/1.3/Fri Apr 3 02:48:03 2009// |
| /HTMLTextAreaElement11.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /HTMLTextAreaElement12.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLTextAreaElement13.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /HTMLTextAreaElement14.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLTextAreaElement15.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /HTMLTitleElement01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /HTMLUListElement01.xml/1.3/Fri Apr 3 02:48:02 2009// |
| /HTMLUListElement02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /alltests.xml/1.10/Fri Apr 3 02:48:01 2009// |
| /anchor01.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /anchor02.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /anchor03.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /anchor04.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /anchor05.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /anchor06.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /area01.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /area02.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /area03.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /area04.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /basefont01.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /body01.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /button01.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /button02.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /button03.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /button04.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /button05.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /button06.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /button07.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /button08.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /button09.xml/1.1/Fri Apr 3 02:48:02 2009// |
| /dlist01.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /doc01.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /hasFeature01.xml/1.1/Fri Apr 3 02:48:03 2009// |
| /index.htm/1.1/Fri Apr 3 02:48:01 2009// |
| /metadata.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /object01.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /object02.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /object03.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /object04.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /object05.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /object06.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /object07.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /object08.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /object09.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /object10.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /object11.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /object12.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /object13.xml/1.4/Fri Apr 3 02:48:02 2009// |
| /object14.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /object15.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table01.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table02.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table03.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /table04.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /table06.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table07.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /table08.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /table09.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table10.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table12.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table15.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table17.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table18.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table19.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table20.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table21.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table22.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table23.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table24.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table25.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table26.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table27.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table28.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table29.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table30.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table31.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /table32.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /table33.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table34.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table35.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table36.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table37.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table38.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table39.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table40.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table41.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table42.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table43.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table44.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table45.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /table46.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /table47.xml/1.2/Fri Apr 3 02:48:03 2009// |
| /table48.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table49.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table50.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table51.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /table52.xml/1.2/Fri Apr 3 02:48:02 2009// |
| /table53.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level1/html |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/CVS/Template |
|---|
| --- test/testcases/tests/level1/html/HTMLAnchorElement01.xml.notimpl (nonexistent) |
| +++ test/testcases/tests/level1/html/HTMLAnchorElement01.xml.notimpl (revision 4364) |
| @@ -0,0 +1,43 @@ |
| +<?xml version="1.0" encoding="UTF-8"?> |
| +<?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| + |
| +<!-- |
| + |
| +Copyright (c) 2001 World Wide Web Consortium, |
| +(Massachusetts Institute of Technology, Institut National de |
| +Recherche en Informatique et en Automatique, Keio University). All |
| +Rights Reserved. This program is distributed under the W3C's Software |
| +Intellectual Property License. This program is distributed in the |
| +hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| +PURPOSE. |
| + |
| +See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| + |
| +--> |
| +<!DOCTYPE test SYSTEM "dom1.dtd"> |
| +<test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement01"> |
| +<metadata> |
| +<title>HTMLAnchorElement01</title> |
| +<creator>NIST</creator> |
| +<description> |
| + The accessKey attribute is a single character access key to give |
| + access to the form control. |
| + |
| + Retrieve the accessKey attribute and examine its value. |
| +</description> |
| +<contributor>Mary Brady</contributor> |
| +<date qualifier="created">2002-02-22</date> |
| +<subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-89647724"/> |
| +</metadata> |
| +<var name="nodeList" type="NodeList"/> |
| +<var name="testNode" type="HTMLAnchorElement"/> |
| +<var name="vaccesskey" type="DOMString" /> |
| +<var name="doc" type="Document"/> |
| +<load var="doc" href="anchor" willBeModified="false"/> |
| +<getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| +<assertSize collection="nodeList" size="1" id="Asize"/> |
| +<item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| +<accessKey interface="HTMLAnchorElement" obj="testNode" var="vaccesskey"/> |
| +<assertEquals actual="vaccesskey" expected='"g"' id="accessKeyLink" ignoreCase="false"/> |
| +</test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement02.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement02"> |
| <metadata> |
| <title>HTMLAnchorElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The charset attribute indicates the character encoding of the linked |
| resource. |
| Retrieve the charset attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-67619266"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="vcharset" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <charset interface="HTMLAnchorElement" obj="testNode" var="vcharset"/> |
| <assertEquals actual="vcharset" expected='"US-ASCII"' id="charsetLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement03.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement03"> |
| <metadata> |
| <title>HTMLAnchorElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The coords attribute is a comma-seperated list of lengths, defining |
| an active region geometry. |
| Retrieve the coords attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-92079539"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="vcoords" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <coords interface="HTMLAnchorElement" obj="testNode" var="vcoords"/> |
| <assertEquals actual="vcoords" expected='"0,0,100,100"' id="coordsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement04.xml.notimpl |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8" ?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement04"> |
| <metadata> |
| <title>HTMLAnchorElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The href attribute contains the URL of the linked resource. |
| Retrieve the href attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88517319"/> |
| </metadata> |
| <var name="nodeList" type="NodeList" /> |
| <var name="testNode" type="HTMLAnchorElement" /> |
| <var name="vhref" type="DOMString" /> |
| <var name="doc" type="Document" /> |
| <load var="doc" href="anchor" willBeModified="false" /> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"' /> |
| <assertSize collection="nodeList" size="1" id="Asize" /> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0" /> |
| <href interface="HTMLAnchorElement" obj="testNode" var="vhref" /> |
| <assertURIEquals actual="vhref" file='"submit.gif"' id="hrefLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement05.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement05"> |
| <metadata> |
| <title>HTMLAnchorElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The hreflang attribute contains the language code of the linked resource. |
| Retrieve the hreflang attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87358513"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="vhreflink" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <hreflang interface="HTMLAnchorElement" obj="testNode" var="vhreflink"/> |
| <assertEquals actual="vhreflink" expected='"en"' id="hreflangLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement06.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement06"> |
| <metadata> |
| <title>HTMLAnchorElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute contains the anchor name. |
| Retrieve the name attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-32783304"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLAnchorElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"Anchor"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement07.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement07"> |
| <metadata> |
| <title>HTMLAnchorElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The rel attribute contains the forward link type. |
| Retrieve the rel attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-3815891"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="vrel" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rel interface="HTMLAnchorElement" obj="testNode" var="vrel"/> |
| <assertEquals actual="vrel" expected='"GLOSSARY"' id="relLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement08.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement08"> |
| <metadata> |
| <title>HTMLAnchorElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The rev attribute contains the reverse link type |
| Retrieve the rev attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-58259771"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="vrev" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rev interface="HTMLAnchorElement" obj="testNode" var="vrev"/> |
| <assertEquals actual="vrev" expected='"STYLESHEET"' id="revLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement09.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement09"> |
| <metadata> |
| <title>HTMLAnchorElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The shape attribute contains the shape of the active area. |
| Retrieve the shape attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-49899808"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="vshape" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <shape interface="HTMLAnchorElement" obj="testNode" var="vshape"/> |
| <assertEquals actual="vshape" expected='"rect"' id="shapeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement10.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement10"> |
| <metadata> |
| <title>HTMLAnchorElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The tabIndex attribute contains an index that represents the elements |
| position in the tabbing order. |
| Retrieve the tabIndex attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-41586466"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="vtabindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tabIndex interface="HTMLAnchorElement" obj="testNode" var="vtabindex"/> |
| <assertEquals actual="vtabindex" expected="22" id="tabIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement11.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement11"> |
| <metadata> |
| <title>HTMLAnchorElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The target attribute specifies the frame to render the source in. |
| Retrieve the target attribute and examine it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6414197"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtarget" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor2" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <target interface="HTMLAnchorElement" obj="testNode" var="vtarget"/> |
| <assertEquals actual="vtarget" expected='"dynamic"' id="targetLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement12.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement12"> |
| <metadata> |
| <title>HTMLAnchorElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute contains the advisory content model. |
| Retrieve the type attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63938221"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLAnchorElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"image/gif"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement13.xml.notimpl |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement13"> |
| <metadata> |
| <title>HTMLAnchorElement13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| HTMLAnchorElement.blur should surrender input focus. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-65068939"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <blur interface="HTMLAnchorElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAnchorElement14.xml.notimpl |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAnchorElement14"> |
| <metadata> |
| <title>HTMLAnchorElement14</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| HTMLAnchorElement.focus should capture input focus. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-47150313"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="HTMLAnchorElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <focus interface="HTMLAnchorElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement01.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement01"> |
| <metadata> |
| <title>HTMLAppletElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the alignment of the object(Vertically |
| or Horizontally) with respect to its surrounding text. |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-8049912"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLAppletElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"bottom"' id="alignLink" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement02.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement02"> |
| <metadata> |
| <title>HTMLAppletElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The alt attribute specifies the alternate text for user agents not |
| rendering the normal context of this element. |
| Retrieve the alt attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-58610064"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valt" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <alt interface="HTMLAppletElement" obj="testNode" var="valt"/> |
| <assertEquals actual="valt" expected='"Applet Number 1"' id="altLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement03.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement03"> |
| <metadata> |
| <title>HTMLAppletElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The archive attribute specifies a comma-seperated archive list. |
| Retrieve the archive attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-14476360"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="varchive" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <archive interface="HTMLAppletElement" obj="testNode" var="varchive"/> |
| <assertEquals actual="varchive" expected='""' id="archiveLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement04.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement04"> |
| <metadata> |
| <title>HTMLAppletElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The code attribute specifies the applet class file. |
| Retrieve the code attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-61509645"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcode" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <code interface="HTMLAppletElement" obj="testNode" var="vcode"/> |
| <assertEquals actual="vcode" expected='"org/w3c/domts/DOMTSApplet.class"' id="codeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement05.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement05"> |
| <metadata> |
| <title>HTMLAppletElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The codeBase attribute specifies an optional base URI for the applet. |
| Retrieve the codeBase attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6581160"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcodebase" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <codeBase interface="HTMLAppletElement" obj="testNode" var="vcodebase"/> |
| <assertEquals actual="vcodebase" expected='"applets"' id="codebase" ignoreCase="false" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement06.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement06"> |
| <metadata> |
| <title>HTMLAppletElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The height attribute overrides the height. |
| Retrieve the height attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-90184867"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheight" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <height interface="HTMLAppletElement" obj="testNode" var="vheight"/> |
| <assertEquals actual="vheight" expected='"306"' id="heightLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement07.xml.notimpl |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement07"> |
| <metadata> |
| <title>HTMLAppletElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The hspace attribute specifies the horizontal space to the left |
| and right of this image, applet, or object. Retrieve the hspace attribute and examine its value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-1567197"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhspace" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <!-- this test is incompatible with L2 HTML implementations --> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <hspace interface="HTMLAppletElement" obj="testNode" var="vhspace"/> |
| <assertEquals actual="vhspace" expected='"0"' id="hspaceLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement08.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement08"> |
| <metadata> |
| <title>HTMLAppletElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute specifies the name of the applet. |
| Retrieve the name attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39843695"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLAppletElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"applet1"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement09.xml.notimpl |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement09"> |
| <metadata> |
| <title>HTMLAppletElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The vspace attribute specifies the vertical space above and below |
| this image, applet or object. Retrieve the vspace attribute and examine its value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-22637173"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvspace" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vspace interface="HTMLAppletElement" obj="testNode" var="vvspace"/> |
| <assertEquals actual="vvspace" expected='"0"' id="vspaceLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement10.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement10"> |
| <metadata> |
| <title>HTMLAppletElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute overrides the regular width. |
| Retrieve the width attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-16526327"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLAppletElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"301"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAppletElement11.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAppletElement11"> |
| <metadata> |
| <title>HTMLAppletElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The object attribute specifies the serialized applet file. |
| Retrieve the object attribute and examine its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-07-19</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-93681523"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vobject" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="applet2" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"applet"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <object interface="HTMLAppletElement" obj="testNode" var="vobject"/> |
| <assertEquals actual="vobject" expected='"DOMTSApplet.dat"' id="object" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAreaElement01.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAreaElement01"> |
| <metadata> |
| <title>HTMLAreaElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The accessKey attribute specifies a single character access key to |
| give access to the control form. |
| Retrieve the accessKey attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-57944457"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaccesskey" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <accessKey interface="HTMLAreaElement" obj="testNode" var="vaccesskey"/> |
| <assertEquals actual="vaccesskey" expected='"a"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAreaElement02.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAreaElement02"> |
| <metadata> |
| <title>HTMLAreaElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The alt attribute specifies an alternate text for user agents not |
| rendering the normal content of this element. |
| Retrieve the alt attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39775416"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valt" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <alt interface="HTMLAreaElement" obj="testNode" var="valt"/> |
| <assertEquals actual="valt" expected='"Domain"' id="altLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAreaElement03.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAreaElement03"> |
| <metadata> |
| <title>HTMLAreaElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The coords attribute specifies a comma-seperated list of lengths, |
| defining an active region geometry. |
| Retrieve the coords attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-66021476"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcoords" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <coords interface="HTMLAreaElement" obj="testNode" var="vcoords"/> |
| <assertEquals actual="vcoords" expected='"0,2,45,45"' id="coordsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAreaElement04.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAreaElement04"> |
| <metadata> |
| <title>HTMLAreaElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The href attribute specifies the URI of the linked resource. |
| Retrieve the href attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-34672936"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhref" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <href interface="HTMLAreaElement" obj="testNode" var="vhref"/> |
| <assertURIEquals actual="vhref" file='"dletter.html"' id="hrefLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAreaElement05.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAreaElement05"> |
| <metadata> |
| <title>HTMLAreaElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The noHref attribute specifies that this area is inactive. |
| Retrieve the noHref attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-61826871"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vnohref" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <noHref interface="HTMLAreaElement" obj="testNode" var="vnohref"/> |
| <assertFalse actual="vnohref" id="noHrefLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAreaElement06.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAreaElement06"> |
| <metadata> |
| <title>HTMLAreaElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The shape attribute specifies the shape of the active area. |
| Retrieve the shape attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-85683271"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vshape" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <shape interface="HTMLAreaElement" obj="testNode" var="vshape"/> |
| <assertEquals actual="vshape" expected='"rect"' id="shapeLink" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAreaElement07.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAreaElement07"> |
| <metadata> |
| <title>HTMLAreaElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The tabIndex attribute specifies an index that represents the element's |
| position in the tabbing order. |
| Retrieve the tabIndex attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-8722121"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtabindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tabIndex interface="HTMLAreaElement" obj="testNode" var="vtabindex"/> |
| <assertEquals actual="vtabindex" expected="10" id="tabIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLAreaElement08.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLAreaElement08"> |
| <metadata> |
| <title>HTMLAreaElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The target specifies the frame to render the resource in. |
| Retrieve the target attribute and examine it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-46054682"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtarget" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="area2" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <target interface="HTMLAreaElement" obj="testNode" var="vtarget"/> |
| <assertEquals actual="vtarget" expected='"dynamic"' id="targetLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBRElement01.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBRElement01"> |
| <metadata> |
| <title>HTMLBRElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The clear attribute specifies control flow of text around floats. |
| Retrieve the clear attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-82703081"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclear" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="br" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"br"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <clear interface="HTMLBRElement" obj="testNode" var="vclear"/> |
| <assertEquals actual="vclear" expected='"none"' id="clearLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBaseElement01.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBaseElement01"> |
| <metadata> |
| <title>HTMLBaseElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The href attribute specifies the base URI. |
| Retrieve the href attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-65382887"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhref" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="base" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"base"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <href interface="HTMLBaseElement" obj="testNode" var="vhref"/> |
| <assertEquals actual="vhref" expected='"about:blank"' id="hrefLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBaseElement02.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBaseElement02"> |
| <metadata> |
| <title>HTMLBaseElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The target attribute specifies the default target frame. |
| Retrieve the target attribute and examine its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-73844298"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtarget" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="base2" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"base"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <target interface="HTMLBaseElement" obj="testNode" var="vtarget"/> |
| <assertEquals actual="vtarget" expected='"Frame1"' id="targetLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBaseFontElement01.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBaseFontElement01"> |
| <metadata> |
| <title>HTMLBaseFontElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The color attribute specifies the base font's color. |
| Retrieve the color attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87502302"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcolor" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="basefont" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"basefont"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <color interface="HTMLBaseFontElement" obj="testNode" var="vcolor"/> |
| <assertEquals actual="vcolor" expected='"#000000"' id="colorLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBaseFontElement02.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBaseFontElement02"> |
| <metadata> |
| <title>HTMLBaseFontElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The face attribute specifies the base font's face identifier. |
| Retrieve the face attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88128969"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vface" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="basefont" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"basefont"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <face interface="HTMLBaseFontElement" obj="testNode" var="vface"/> |
| <assertEquals actual="vface" expected='"arial,helvitica"' id="faceLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBaseFontElement03.xml.notimpl |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBaseFontElement03"> |
| <metadata> |
| <title>HTMLBaseFontElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The size attribute specifies the base font's size. Retrieve the size attribute and examine its value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-38930424"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsize" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="basefont" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"basefont"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <size interface="HTMLBaseFontElement" obj="testNode" var="vsize"/> |
| <assertEquals actual="vsize" expected='"4"' id="sizeLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBodyElement01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBodyElement01"> |
| <metadata> |
| <title>HTMLBodyElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The aLink attribute specifies the color of active links. |
| Retrieve the aLink attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59424581"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valink" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="body" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"body"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <aLink interface="HTMLBodyElement" obj="testNode" var="valink"/> |
| <assertEquals actual="valink" expected='"#0000ff"' id="aLinkLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBodyElement02.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBodyElement02"> |
| <metadata> |
| <title>HTMLBodyElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The background attribute specifies the URI fo the background texture |
| tile image. |
| Retrieve the background attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-37574810"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vbackground" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="body" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"body"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <background interface="HTMLBodyElement" obj="testNode" var="vbackground"/> |
| <assertEquals actual="vbackground" expected='"./pix/back1.gif"' id="backgroundLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBodyElement03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBodyElement03"> |
| <metadata> |
| <title>HTMLBodyElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The bgColor attribute specifies the document background color. |
| Retrieve the bgColor attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-24940084"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vbgcolor" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="body" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"body"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <bgColor interface="HTMLBodyElement" obj="testNode" var="vbgcolor"/> |
| <assertEquals actual="vbgcolor" expected='"#ffff00"' id="bgColorLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBodyElement04.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBodyElement04"> |
| <metadata> |
| <title>HTMLBodyElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The link attribute specifies the color of links that are not active |
| and unvisited. |
| Retrieve the link attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-7662206"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlink" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="body" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"body"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <link interface="HTMLBodyElement" obj="testNode" var="vlink"/> |
| <assertEquals actual="vlink" expected='"#ff0000"' id="linkLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBodyElement05.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBodyElement05"> |
| <metadata> |
| <title>HTMLBodyElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The text attribute specifies the document text color. |
| Retrieve the text attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-73714763"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtext" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="body" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"body"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <text interface="HTMLBodyElement" obj="testNode" var="vtext"/> |
| <assertEquals actual="vtext" expected='"#000000"' id="textLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLBodyElement06.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLBodyElement06"> |
| <metadata> |
| <title>HTMLBodyElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The vLink attribute specifies the color of links that have been |
| visited by the user. |
| Retrieve the vLink attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83224305"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvlink" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="body" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"body"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vLink interface="HTMLBodyElement" obj="testNode" var="vvlink"/> |
| <assertEquals actual="vvlink" expected='"#00ffff"' id="vLinkLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLButtonElement01.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLButtonElement01"> |
| <metadata> |
| <title>HTMLButtonElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns the FORM element containing this control. |
| Retrieve the form attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-71254493"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="fNode" type="HTMLFormElement"/> |
| <var name="vform" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLButtonElement" obj="testNode" var="fNode"/> |
| <id obj="fNode" var="vform"/> |
| <assertEquals actual="vform" expected='"form2"' id="formLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLButtonElement02.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLButtonElement02"> |
| <metadata> |
| <title>HTMLButtonElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns null if control in not within the context of |
| form. |
| Retrieve the form attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-71254493"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="HTMLFormElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <form interface="HTMLButtonElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formNullLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLButtonElement03.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLButtonElement03"> |
| <metadata> |
| <title>HTMLButtonElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The accessKey attribute returns a single character access key to |
| give access to the form control. |
| Retrieve the accessKey attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-73169431"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaccesskey" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <accessKey interface="HTMLButtonElement" obj="testNode" var="vaccesskey"/> |
| <assertEquals actual="vaccesskey" expected='"f"' id="accessKeyLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLButtonElement04.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLButtonElement04"> |
| <metadata> |
| <title>HTMLButtonElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The disabled attribute specifies whether the control is unavailable |
| in this context. |
| Retrieve the disabled attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-92757155"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdisabled" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <disabled interface="HTMLButtonElement" obj="testNode" var="vdisabled"/> |
| <assertTrue actual="vdisabled" id="disabledLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLButtonElement05.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLButtonElement05"> |
| <metadata> |
| <title>HTMLButtonElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute is the form control or object name when submitted |
| with a form. |
| Retrieve the name attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-11029910"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLButtonElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"disabledButton"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLButtonElement06.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLButtonElement06"> |
| <metadata> |
| <title>HTMLButtonElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The tabIndex attribute specifies an index that represents the element's |
| position in the tabbing order. |
| Retrieve the tabIndex attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39190908"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtabindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tabIndex interface="HTMLButtonElement" obj="testNode" var="vtabindex"/> |
| <assertEquals actual="vtabindex" expected="20" id="tabIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLButtonElement07.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLButtonElement07"> |
| <metadata> |
| <title>HTMLButtonElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute specifies the type of button. |
| Retrieve the type attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-27430092"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLButtonElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"reset"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLButtonElement08.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLButtonElement08"> |
| <metadata> |
| <title>HTMLButtonElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The value attribute specifies the current control value. |
| Retrieve the value attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-72856782"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalue" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <value interface="HTMLButtonElement" obj="testNode" var="vvalue"/> |
| <assertEquals actual="vvalue" expected='"Reset Disabled Button"' id="valueLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection01.xml.notimpl |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection01"> |
| <metadata> |
| <title>HTMLCollection01</title> |
| <creator>NIST</creator> |
| <description> |
| An individual node may be accessed by either ordinal index, the node's |
| name or id attributes. (Test ordinal index). |
| Retrieve the first TABLE element and create a HTMLCollection by invoking |
| the "rows" attribute. The item located at ordinal index 0 is further |
| retrieved and its "rowIndex" attribute is examined. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-33262535"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrowindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <item interface="HTMLCollection" obj="rowsnodeList" var="rowNode" index="0"/> |
| <rowIndex interface="HTMLTableRowElement" obj="rowNode" var="vrowindex"/> |
| <assertEquals actual="vrowindex" expected="0" id="rowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection02.xml.kfail |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection02"> |
| <metadata> |
| <title>HTMLCollection02</title> |
| <creator>NIST</creator> |
| <description> |
| An individual node may be accessed by either ordinal index, the node's |
| name or id attributes. (Test node name). |
| Retrieve the first FORM element and create a HTMLCollection by invoking |
| the elements attribute. The first SELECT element is further retrieved |
| using the elements name attribute. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-76728479"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="formNode" type="Node"/> |
| <var name="formsnodeList" type="HTMLCollection"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <elements interface="HTMLFormElement" obj="testNode" var="formsnodeList"/> |
| <namedItem obj="formsnodeList" var="formNode" name='"select1"'/> |
| <nodeName obj="formNode" var="vname"/> |
| <assertEquals actual="vname" expected='"SELECT"' id="nameIndexLink" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection03.xml.kfail |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection03"> |
| <metadata> |
| <title>HTMLCollection03</title> |
| <creator>NIST</creator> |
| <description> |
| An individual node may be accessed by either ordinal index, the node's |
| name or id attributes. (Test id attribute). |
| Retrieve the first FORM element and create a HTMLCollection by invoking |
| the "element" attribute. The first SELECT element is further retrieved |
| using the elements id. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-21069976"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="formNode" type="Node"/> |
| <var name="formsnodeList" type="HTMLCollection"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <elements interface="HTMLFormElement" obj="testNode" var="formsnodeList"/> |
| <namedItem obj="formsnodeList" var="formNode" name='"selectId"'/> |
| <nodeName obj="formNode" var="vname"/> |
| <assertEquals actual="vname" expected='"select"' id="nameIndexLink" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection04.xml.notimpl |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection04"> |
| <metadata> |
| <title>HTMLCollection04</title> |
| <creator>NIST</creator> |
| <description> |
| HTMLCollections are live, they are automatically updated when the |
| underlying document is changed. |
| Create a HTMLCollection object by invoking the rows attribute of the |
| first TABLE element and examine its length, then add a new row and |
| re-examine the length. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-40057551"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowLength1" type="int"/> |
| <var name="rowLength2" type="int"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="vrowindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <var name="result" type="List"/> |
| <var name="expectedResult" type="List"> |
| <member>4</member> |
| <member>5</member> |
| </var> |
| <load var="doc" href="collection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="rowLength1"/> |
| <append collection="result" item="rowLength1"/> |
| <insertRow interface="HTMLTableElement" obj="testNode" var="newRow" index="4"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="rowLength2"/> |
| <append collection="result" item="rowLength2"/> |
| <assertEquals actual="result" expected="expectedResult" id="rowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection05.xml.notimpl |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection05"> |
| <metadata> |
| <title>HTMLCollection05</title> |
| <creator>NIST</creator> |
| <description> |
| The length attribute specifies the length or size of the list. |
| Retrieve the first TABLE element and create a HTMLCollection by invoking |
| the "rows" attribute. Retrieve the length attribute of the HTMLCollection |
| object. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-40057551"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="rowLength" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="rowLength"/> |
| <assertEquals actual="rowLength" expected="4" id="rowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection06.xml.notimpl |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection06"> |
| <metadata> |
| <title>HTMLCollection06</title> |
| <creator>NIST</creator> |
| <description> |
| An item(index) method retrieves an item specified by ordinal index |
| (Test for index=0). |
| Retrieve the first TABLE element and create a HTMLCollection by invoking |
| the "rows" attribute. The item located at ordinal index 0 is further |
| retrieved and its "rowIndex" attribute is examined. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6156016"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-33262535"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrowindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <item interface="HTMLCollection" obj="rowsnodeList" var="rowNode" index="0"/> |
| <rowIndex interface="HTMLTableRowElement" obj="rowNode" var="vrowindex"/> |
| <assertEquals actual="vrowindex" expected="0" id="rowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection07.xml.notimpl |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection07"> |
| <metadata> |
| <title>HTMLCollection07</title> |
| <creator>NIST</creator> |
| <description> |
| An item(index) method retrieves an item specified by ordinal index |
| (Test for index=3). |
| Retrieve the first TABLE element and create a HTMLCollection by invoking |
| the "rows" attribute. The item located at ordinal index 3 is further |
| retrieved and its "rowIndex" attribute is examined. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-33262535"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrowindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <item interface="HTMLCollection" obj="rowsnodeList" var="rowNode" index="3"/> |
| <rowIndex interface="HTMLTableRowElement" obj="rowNode" var="vrowindex"/> |
| <assertEquals actual="vrowindex" expected="3" id="rowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection08.xml.notimpl |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection08"> |
| <metadata> |
| <title>HTMLCollection08</title> |
| <creator>NIST</creator> |
| <description> |
| Nodes in a HTMLCollection object are numbered in tree order. |
| (Depth-first traversal order). |
| Retrieve the first TABLE element and create a HTMLCollection by invoking |
| the "rows" attribute. Access the item in the third ordinal index. The |
| resulting rowIndex attribute is examined and should be two. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-33262535"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrowindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <item interface="HTMLCollection" obj="rowsnodeList" var="rowNode" index="2"/> |
| <rowIndex interface="HTMLTableRowElement" obj="rowNode" var="vrowindex"/> |
| <assertEquals actual="vrowindex" expected="2" id="rowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection09.xml.notimpl |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection09"> |
| <metadata> |
| <title>HTMLCollection09</title> |
| <creator>NIST</creator> |
| <description> |
| The item(index) method returns null if the index is out of range. |
| Retrieve the first TABLE element and create a HTMLCollection by invoking |
| the "rows" attribute. Invoke the item(index) method with an index |
| of 5. This index is out of range and should return null. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-33262535"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrowindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <item interface="HTMLCollection" obj="rowsnodeList" var="rowNode" index="5"/> |
| <assertNull actual="rowNode" id="rowIndexLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection10.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection10"> |
| <metadata> |
| <title>HTMLCollection10</title> |
| <creator>NIST</creator> |
| <description> |
| The namedItem(name) method retrieves a node using a name. It first |
| searches for a node with a matching id attribute. If it doesn't find |
| one, it then searches for a Node with a matching name attribute, but only |
| on those elements that are allowed a name attribute. |
| Retrieve the first FORM element and create a HTMLCollection by invoking |
| the elements attribute. The first SELECT element is further retrieved |
| using the elements name attribute since the id attribute doesn't match. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-21069976"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="formNode" type="Node"/> |
| <var name="formsnodeList" type="HTMLCollection"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <elements interface="HTMLFormElement" obj="testNode" var="formsnodeList"/> |
| <namedItem obj="formsnodeList" var="formNode" name='"select1"'/> |
| <nodeName obj="formNode" var="vname"/> |
| <assertEquals actual="vname" expected='"SELECT"' id="nameIndexLink" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection11.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection11"> |
| <metadata> |
| <title>HTMLCollection11</title> |
| <creator>NIST</creator> |
| <description> |
| The namedItem(name) method retrieves a node using a name. It first |
| searches for a node with a matching id attribute. If it doesn't find |
| one, it then searches for a Node with a matching name attribute, but only |
| on those elements that are allowed a name attribute. |
| Retrieve the first FORM element and create a HTMLCollection by invoking |
| the elements attribute. The first SELECT element is further retrieved |
| using the elements id attribute. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-76728479"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="formNode" type="Node"/> |
| <var name="formsnodeList" type="HTMLCollection"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <elements interface="HTMLFormElement" obj="testNode" var="formsnodeList"/> |
| <namedItem obj="formsnodeList" var="formNode" name='"selectId"'/> |
| <nodeName obj="formNode" var="vname"/> |
| <assertEquals actual="vname" expected='"select"' id="nameIndexLink" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLCollection12.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLCollection12"> |
| <metadata> |
| <title>HTMLCollection12</title> |
| <creator>NIST</creator> |
| <description> |
| The namedItem(name) method retrieves a node using a name. It first |
| searches for a node with a matching id attribute. If it doesn't find |
| one, it then searches for a Node with a matching name attribute, but only |
| on those elements that are allowed a name attribute. If there isn't |
| a matching node the method returns null. |
| Retrieve the first FORM element and create a HTMLCollection by invoking |
| the elements attribute. The method returns null since there is not a |
| match of the name or id attribute. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-01</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-21069976"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="formNode" type="Node"/> |
| <var name="formsnodeList" type="HTMLCollection"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="collection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <elements interface="HTMLFormElement" obj="testNode" var="formsnodeList"/> |
| <namedItem obj="formsnodeList" var="formNode" name='"select9"'/> |
| <assertNull actual="formNode" id="nameIndexLink" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDirectoryElement01.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDirectoryElement01"> |
| <metadata> |
| <title>HTMLDirectoryElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The compact attribute specifies a boolean value on whether to display |
| the list more compactly. |
| Retrieve the compact attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-75317739"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcompact" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="directory" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dir"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <compact interface="HTMLDirectoryElement" obj="testNode" var="vcompact"/> |
| <assertTrue actual="vcompact" id="compactLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDivElement01.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDivElement01"> |
| <metadata> |
| <title>HTMLDivElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal text alignment. |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-70908791"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="div" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"div"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLDivElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDlistElement01.xml.notimpl |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDlistElement01"> |
| <metadata> |
| <title>HTMLDListElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The compact attribute specifies a boolean value on whether to display |
| the list more compactly. |
| Retrieve the compact attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-21738539"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcompact" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="dl" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dl"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <compact interface="HTMLDListElement" obj="testNode" var="vcompact"/> |
| <assertTrue actual="vcompact" id="compactLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument01.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument01"> |
| <metadata> |
| <title>HTMLDocument01</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute is the specified title as a string. |
| Retrieve the title attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-01-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-18446827"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="vtitle" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <title interface="HTMLDocument" obj="doc" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"NIST DOM HTML Test - DOCUMENT"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument02.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument02"> |
| <metadata> |
| <title>HTMLDocument02</title> |
| <creator>NIST</creator> |
| <description> |
| The referrer attribute returns the URI of the page that linked to this |
| page. |
| Retrieve the referrer attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-01-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95229140"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vreferrer" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <referrer interface="HTMLDocument" obj="doc" var="vreferrer"/> |
| <assertEquals actual="vreferrer" expected='""' id="referrerLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument03.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument03"> |
| <metadata> |
| <title>HTMLDocument03</title> |
| <creator>NIST</creator> |
| <description> |
| The domain attribute specifies the domain name of the server that served |
| the document, or null if the server cannot be identified by a domain name. |
| Retrieve the domain attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-01-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-2250147"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdomain" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <domain interface="HTMLDocument" obj="doc" var="vdomain"/> |
| <assertEquals actual="vdomain" expected='""' id="domainLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument04.xml.notimpl |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument04"> |
| <metadata> |
| <title>HTMLDocument04</title> |
| <creator>NIST</creator> |
| <description> |
| The URL attribute specifies the absolute URI of the document. |
| Retrieve the URL attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-01-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-46183437"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vurl" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <URL interface="HTMLDocument" obj="doc" var="vurl"/> |
| <assertURIEquals actual="vurl" name='"document"' id="URLLink" isAbsolute="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument05.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument05"> |
| <metadata> |
| <title>HTMLDocument05</title> |
| <creator>NIST</creator> |
| <description> |
| The body attribute is the element that contains the content for the |
| document. |
| Retrieve the body attribute and examine its value for the id attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-01-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-56360201"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vbody" type="HTMLElement" /> |
| <var name="vid" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <body interface="HTMLDocument" obj="doc" var="vbody"/> |
| <id interface="HTMLElement" obj="vbody" var="vid"/> |
| <assertEquals actual="vid" expected='"TEST-BODY"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument07.xml.notimpl |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument07"> |
| <metadata> |
| <title>HTMLDocument07</title> |
| <creator>NIST</creator> |
| <description> |
| The images attribute returns a collection of all IMG elements in a document. |
| Retrieve the images attribute from the document and examine its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-90379117"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vimages" type="HTMLCollection" /> |
| <var name="vlength" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <images interface="HTMLDocument" obj="doc" var="vimages" /> |
| <length interface="HTMLCollection" obj="vimages" var="vlength" /> |
| <assertEquals actual="vlength" expected='1' id="lengthLink" ignoreCase="false" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument08.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument08"> |
| <metadata> |
| <title>HTMLDocument08</title> |
| <creator>NIST</creator> |
| <description> |
| The applets attribute returns a collection of all OBJECT elements that |
| include applets abd APPLET elements in a document. |
| Retrieve the applets attribute from the document and examine its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-85113862"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vapplets" type="HTMLCollection" /> |
| <var name="vlength" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <applets interface="HTMLDocument" obj="doc" var="vapplets" /> |
| <length interface="HTMLCollection" obj="vapplets" var="vlength" /> |
| <assertEquals actual="vlength" expected='4' id="length" ignoreCase="false" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument09.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument09"> |
| <metadata> |
| <title>HTMLDocument09</title> |
| <creator>NIST</creator> |
| <description> |
| The links attribute returns a collection of all AREA and A elements |
| in a document with a value for the href attribute. |
| Retrieve the links attribute from the document and examine its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-7068919"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlinks" type="HTMLCollection"/> |
| <var name="vlength" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <links interface="HTMLDocument" obj="doc" var="vlinks" /> |
| <length interface="HTMLCollection" obj="vlinks" var="vlength" /> |
| <assertEquals actual="vlength" expected='3' id="lengthLink" ignoreCase="false" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument10.xml.notimpl |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument10"> |
| <metadata> |
| <title>HTMLDocument10</title> |
| <creator>NIST</creator> |
| <description> |
| The forms attribute returns a collection of all the forms in a document. |
| Retrieve the forms attribute from the document and examine its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-1689064"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vforms" type="HTMLCollection"/> |
| <var name="vlength" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <forms interface="HTMLDocument" obj="doc" var="vforms" /> |
| <length interface="HTMLCollection" obj="vforms" var="vlength" /> |
| <assertEquals actual="vlength" expected='1' id="lengthLink" ignoreCase="false" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument11.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument11"> |
| <metadata> |
| <title>HTMLDocument11</title> |
| <creator>NIST</creator> |
| <description> |
| The anchors attribute returns a collection of all A elements with values |
| for the name attribute. |
| Retrieve the anchors attribute from the document and examine its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-7577272"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vanchors" type="HTMLCollection"/> |
| <var name="vlength" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <anchors interface="HTMLDocument" obj="doc" var="vanchors" /> |
| <length interface="HTMLCollection" obj="vanchors" var="vlength" /> |
| <assertEquals actual="vlength" expected='1' id="lengthLink" ignoreCase="false" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument12.xml.notimpl |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument12"> |
| <metadata> |
| <title>HTMLDocument02</title> |
| <creator>NIST</creator> |
| <description> |
| The cookie attribute returns the cookies associated with this document. |
| Retrieve the cookie attribute and examine its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-8747038"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="vcookie" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <cookie interface="HTMLDocument" obj="doc" var="vcookie"/> |
| <assertEquals actual="vcookie" expected='""' id="cookieLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument13.xml.notimpl |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument13"> |
| <metadata> |
| <title>HTMLDocument13</title> |
| <creator>NIST</creator> |
| <description> |
| The getElementsByName method returns the (possibly empty) collection |
| of elements whose name value is given by the elementName. |
| Retrieve all the elements whose name attribute is "mapid". |
| Check the length of the nodelist. It should be 1. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-71555259"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <getElementsByName interface="HTMLDocument" var="nodeList" obj="doc" elementName='"mapid"' id="getElementsNameId"/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument14.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument14"> |
| <metadata> |
| <title>HTMLDocument14</title> |
| <creator>NIST</creator> |
| <description> |
| The getElementsByName method returns the (possibly empty) collection |
| of elements whose name value is given by the elementName. |
| Retrieve all the elements whose name attribute is "noid". |
| Check the length of the nodelist. It should be 0 since |
| the id "noid" does not exist. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-71555259"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <getElementsByName interface="HTMLDocument" var="nodeList" obj="doc" elementName='"noid"' id="getElementsNameId"/> |
| <assertSize collection="nodeList" size="0" id="Asize"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument15.xml.notimpl |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument15"> |
| <metadata> |
| <title>HTMLDocument15</title> |
| <creator>NIST</creator> |
| <description> |
| The getElementById method returns the Element whose id is given by |
| elementId. If no such element exists, returns null. |
| Retrieve the element whose id is "mapid". |
| Check the value of the element. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-36113835"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-26809268"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBId"/> |
| </metadata> |
| <var name="elementNode" type="Element"/> |
| <var name="elementValue" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <getElementById var="elementNode" obj="doc" elementId='"mapid"' id="getElementsId"/> |
| <nodeName obj="elementNode" var="elementValue"/> |
| <assertEquals actual="elementValue" expected='"map"' id="elementId" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument16.xml.notimpl |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument16"> |
| <metadata> |
| <title>HTMLDocument16</title> |
| <creator>NIST</creator> |
| <description> |
| The getElementById method returns the Element whose id is given by |
| elementId. If no such element exists, returns null. |
| Retrieve the element whose id is "noid". |
| The value returned should be null since there are not any elements with |
| an id of "noid". |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-36113835"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-26809268"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBId"/> |
| </metadata> |
| <var name="elementNode" type="Element"/> |
| <var name="elementValue" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <getElementById var="elementNode" obj="doc" elementId='"noid"' id="getElementsId"/> |
| <assertNull actual="elementNode" id="elementId"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument17.xml.notimpl |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument17"> |
| <metadata> |
| <title>HTMLDocument17</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Clears the current document using HTMLDocument.open immediately followed by close. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-72161170"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-98948567"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="bodyElem" type="Element"/> |
| <var name="bodyChild" type="Node"/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <open obj="doc"/> |
| <close obj="doc"/> |
| <body var="bodyElem" obj="doc"/> |
| <if><notNull obj="bodyElem"/> |
| <firstChild interface="Node" var="bodyChild" obj="bodyElem"/> |
| <assertNull actual="bodyChild" id="bodyContainsChildren"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument18.xml.notimpl |
|---|
| 0,0 → 1,32 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument18"> |
| <metadata> |
| <title>HTMLDocument18</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Calls HTMLDocument.close on a document that has not been opened for modification. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-98948567"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <close obj="doc"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument19.xml.notimpl |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument19"> |
| <metadata> |
| <title>HTMLDocument19</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Replaces the current document with a valid HTML document using HTMLDocument.open, write and close. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-72161170"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-98948567"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-75233634"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="title" type="DOMString"/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <open obj="doc"/> |
| <if><contentType type="text/html"/> |
| <write obj="doc" text='"<html>"'/> |
| <else> |
| <write obj="doc" text='"<html xmlns='http://www.w3.org/1999/xhtml'>"'/> |
| </else> |
| </if> |
| <write obj="doc" text='"<body>"'/> |
| <write obj="doc" text='"<title>Replacement</title>"'/> |
| <write obj="doc" text='"</body>"'/> |
| <write obj="doc" text='"<p>"'/> |
| <write obj="doc" text='"Hello, World."'/> |
| <write obj="doc" text='"</p>"'/> |
| <write obj="doc" text='"</body>"'/> |
| <write obj="doc" text='"</html>"'/> |
| <close obj="doc"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument20.xml.notimpl |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument20"> |
| <metadata> |
| <title>HTMLDocument20</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Replaces the current document with a valid HTML document using HTMLDocument.open, writeln and close. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-72161170"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-98948567"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-35318390"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="title" type="DOMString"/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <open obj="doc"/> |
| <if><contentType type="text/html"/> |
| <writeln obj="doc" text='"<html>"'/> |
| <else> |
| <writeln obj="doc" text='"<html xmlns='http://www.w3.org/1999/xhtml'>"'/> |
| </else> |
| </if> |
| <writeln obj="doc" text='"<body>"'/> |
| <writeln obj="doc" text='"<title>Replacement</title>"'/> |
| <writeln obj="doc" text='"</body>"'/> |
| <writeln obj="doc" text='"<p>"'/> |
| <writeln obj="doc" text='"Hello, World."'/> |
| <writeln obj="doc" text='"</p>"'/> |
| <writeln obj="doc" text='"</body>"'/> |
| <writeln obj="doc" text='"</html>"'/> |
| <close obj="doc"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLDocument21.xml.notimpl |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLDocument21"> |
| <metadata> |
| <title>HTMLDocument21</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Replaces the current document checks that writeln adds a new line. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-72161170"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-98948567"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-75233634"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-35318390"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="preElems" type="NodeList"/> |
| <var name="preElem" type="Element"/> |
| <var name="preText" type="Text"/> |
| <var name="preValue" type="DOMString"/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <open obj="doc"/> |
| <if><contentType type="text/html"/> |
| <writeln obj="doc" text='"<html>"'/> |
| <else> |
| <writeln obj="doc" text='"<html xmlns='http://www.w3.org/1999/xhtml'>"'/> |
| </else> |
| </if> |
| <writeln obj="doc" text='"<body>"'/> |
| <writeln obj="doc" text='"<title>Replacement</title>"'/> |
| <writeln obj="doc" text='"</body>"'/> |
| <write obj="doc" text='"<pre>"'/> |
| <writeln obj="doc" text='"Hello, World."'/> |
| <writeln obj="doc" text='"Hello, World."'/> |
| <writeln obj="doc" text='"</pre>"'/> |
| <write obj="doc" text='"<pre>"'/> |
| <write obj="doc" text='"Hello, World."'/> |
| <write obj="doc" text='"Hello, World."'/> |
| <writeln obj="doc" text='"</pre>"'/> |
| <writeln obj="doc" text='"</body>"'/> |
| <writeln obj="doc" text='"</html>"'/> |
| <close obj="doc"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement01"> |
| <metadata> |
| <title>HTMLElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the HEAD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"head"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-HEAD"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement02"> |
| <metadata> |
| <title>HTMLElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the SUB element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"sub"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-SUB"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement03"> |
| <metadata> |
| <title>HTMLElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the SUP element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"sup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-SUP"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement04.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement04"> |
| <metadata> |
| <title>HTMLElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the SPAN element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"span"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-SPAN"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement05.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement05"> |
| <metadata> |
| <title>HTMLElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the BDO element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"bdo"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-BDO"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement06.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement06"> |
| <metadata> |
| <title>HTMLElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the TT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tt"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-TT"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement07.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement07"> |
| <metadata> |
| <title>HTMLElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the I element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"i"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-I"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement08.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement08"> |
| <metadata> |
| <title>HTMLElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the B element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"b"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-B"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement09.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement09"> |
| <metadata> |
| <title>HTMLElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the U element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"u"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-U"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement10.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement10"> |
| <metadata> |
| <title>HTMLElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the S element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"s"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-S"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement100.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement100"> |
| <metadata> |
| <title>HTMLElement100</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the SMALL element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"small"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement101.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement101"> |
| <metadata> |
| <title>HTMLElement101</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the EM element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"em"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement102.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement102"> |
| <metadata> |
| <title>HTMLElement102</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the STRONG element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"strong"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement103.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement103"> |
| <metadata> |
| <title>HTMLElement103</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the DFN element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dfn"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement104.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement104"> |
| <metadata> |
| <title>HTMLElement104</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the CODE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"code"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement105.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement105"> |
| <metadata> |
| <title>HTMLElement105</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the SAMP element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"samp"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement106.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement106"> |
| <metadata> |
| <title>HTMLElement106</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the KBD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"kbd"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement107.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement107"> |
| <metadata> |
| <title>HTMLElement107</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the VAR element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"var"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement108.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement108"> |
| <metadata> |
| <title>HTMLElement108</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the CITE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"cite"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement109.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement109"> |
| <metadata> |
| <title>HTMLElement109</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the ACRONYM element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"acronym"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement11.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement11"> |
| <metadata> |
| <title>HTMLElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the STRIKE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"strike"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-STRIKE"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement110.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement110"> |
| <metadata> |
| <title>HTMLElement110</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the ABBR element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"abbr"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement111.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement111"> |
| <metadata> |
| <title>HTMLElement111</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the DD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dd"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement112.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement112"> |
| <metadata> |
| <title>HTMLElement112</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the DT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dt"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement113.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement113"> |
| <metadata> |
| <title>HTMLElement113</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the NOFRAMES element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"noframes"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement114.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement114"> |
| <metadata> |
| <title>HTMLElement114</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the NOSCRIPT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"noscript"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement115.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement115"> |
| <metadata> |
| <title>HTMLElement115</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the ADDRESS element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"address"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement116.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement116"> |
| <metadata> |
| <title>HTMLElement116</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the CENTER element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"center"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement117.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement117"> |
| <metadata> |
| <title>HTMLElement117</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the HEAD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"head"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"HEAD-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement118.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement118"> |
| <metadata> |
| <title>HTMLElement118</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the SUB element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"sub"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"SUB-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement119.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement119"> |
| <metadata> |
| <title>HTMLElement119</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the SUP element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"sup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"SUP-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement12.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement12"> |
| <metadata> |
| <title>HTMLElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the BIG element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"big"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-BIG"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement120.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement120"> |
| <metadata> |
| <title>HTMLElement120</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the SPAN element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"span"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"SPAN-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement121.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement121"> |
| <metadata> |
| <title>HTMLElement121</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the BDO element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"bdo"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"BDO-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement122.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement122"> |
| <metadata> |
| <title>HTMLElement122</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the TT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tt"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"TT-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement123.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement123"> |
| <metadata> |
| <title>HTMLElement123</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the I element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"i"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"I-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement124.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement124"> |
| <metadata> |
| <title>HTMLElement124</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the B element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"b"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"B-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement125.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement125"> |
| <metadata> |
| <title>HTMLElement125</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the U element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"u"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"U-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement126.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement126"> |
| <metadata> |
| <title>HTMLElement126</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the S element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"s"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"S-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement127.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement127"> |
| <metadata> |
| <title>HTMLElement127</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the STRIKE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"strike"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"STRIKE-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement128.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement128"> |
| <metadata> |
| <title>HTMLElement128</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the BIG element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"big"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"BIG-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement129.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement129"> |
| <metadata> |
| <title>HTMLElement129</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the SMALL element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"small"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"SMALL-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement13.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement13"> |
| <metadata> |
| <title>HTMLElement13</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the SMALL element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"small"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-SMALL"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement130.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement130"> |
| <metadata> |
| <title>HTMLElement130</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the EM element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"em"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"EM-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement131.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement131"> |
| <metadata> |
| <title>HTMLElement131</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the STRONG element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"strong"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"STRONG-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement132.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement132"> |
| <metadata> |
| <title>HTMLElement132</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the DFN element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dfn"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"DFN-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement133.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement133"> |
| <metadata> |
| <title>HTMLElement133</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the CODE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"code"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"CODE-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement134.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement134"> |
| <metadata> |
| <title>HTMLElement134</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the SAMP element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"samp"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"SAMP-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement135.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement135"> |
| <metadata> |
| <title>HTMLElement135</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the KBD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"kbd"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"KBD-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement136.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement136"> |
| <metadata> |
| <title>HTMLElement136</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the VAR element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"var"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"VAR-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement137.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement137"> |
| <metadata> |
| <title>HTMLElement137</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the CITE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"cite"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"CITE-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement138.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement138"> |
| <metadata> |
| <title>HTMLElement138</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the ACRONYM element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"acronym"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"ACRONYM-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement139.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement139"> |
| <metadata> |
| <title>HTMLElement139</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the ABBR element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"abbr"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"ABBR-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement14.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement14"> |
| <metadata> |
| <title>HTMLElement14</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the EM element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"em"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-EM"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement140.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement140"> |
| <metadata> |
| <title>HTMLElement140</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the DD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dd"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"DD-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement141.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement141"> |
| <metadata> |
| <title>HTMLElement141</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the DT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dt"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"DT-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement142.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement142"> |
| <metadata> |
| <title>HTMLElement142</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the NOFRAMES element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"noframes"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"NOFRAMES-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement143.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement143"> |
| <metadata> |
| <title>HTMLElement143</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the NOSCRIPT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"noscript"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"NOSCRIPT-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement144.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement144"> |
| <metadata> |
| <title>HTMLElement144</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the ADDRESS element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"address"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"ADDRESS-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement145.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement145"> |
| <metadata> |
| <title>HTMLElement145</title> |
| <creator>NIST</creator> |
| <description> |
| The className attribute specifies the class attribute of the element. |
| Retrieve the class attribute of the CENTER element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95362176"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vclassname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"center"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <className interface="HTMLElement" obj="testNode" var="vclassname"/> |
| <assertEquals actual="vclassname" expected='"CENTER-class"' id="classNameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement15.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement15"> |
| <metadata> |
| <title>HTMLElement15</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the STRONG element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"strong"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-STRONG"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement16.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement16"> |
| <metadata> |
| <title>HTMLElement16</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the DFN element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dfn"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-DFN"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement17.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement17"> |
| <metadata> |
| <title>HTMLElement17</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the CODE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"code"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-CODE"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement18.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement18"> |
| <metadata> |
| <title>HTMLElement18</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the SAMP element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"samp"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-SAMP"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement19.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement19"> |
| <metadata> |
| <title>HTMLElement19</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the KBD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"kbd"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-KBD"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement20.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement20"> |
| <metadata> |
| <title>HTMLElement20</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the VAR element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"var"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-VAR"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement21.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement21"> |
| <metadata> |
| <title>HTMLElement21</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the CITE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"cite"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-CITE"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement22.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement22"> |
| <metadata> |
| <title>HTMLElement22</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the ACRONYM element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"acronym"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-ACRONYM"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement23.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement23"> |
| <metadata> |
| <title>HTMLElement23</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the ABBR element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"abbr"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-ABBR"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement24.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement24"> |
| <metadata> |
| <title>HTMLElement24</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the DD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dd"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-DD"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement25.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement25"> |
| <metadata> |
| <title>HTMLElement25</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the DT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dt"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-DT"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement26.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement26"> |
| <metadata> |
| <title>HTMLElement26</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the NOFRAMES element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"noframes"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-NOFRAMES"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement27.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement27"> |
| <metadata> |
| <title>HTMLElement27</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the NOSCRIPT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"noscript"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-NOSCRIPT"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement28.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement28"> |
| <metadata> |
| <title>HTMLElement28</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the ADDRESS element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"address"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-ADDRESS"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement29.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement29"> |
| <metadata> |
| <title>HTMLElement29</title> |
| <creator>NIST</creator> |
| <description> |
| The id specifies the elements identifier. |
| Retrieve the id attribute of the CENTER element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vid" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"center"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id interface="HTMLElement" obj="testNode" var="vid"/> |
| <assertEquals actual="vid" expected='"Test-CENTER"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement30.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement30"> |
| <metadata> |
| <title>HTMLElement30</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the HEAD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"head"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"HEAD Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement31.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement31"> |
| <metadata> |
| <title>HTMLElement31</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the SUB element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"sub"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"SUB Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement32.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement32"> |
| <metadata> |
| <title>HTMLElement32</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the SUP element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"sup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"SUP Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement33.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement33"> |
| <metadata> |
| <title>HTMLElement33</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the SPAN element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"span"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"SPAN Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement34.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement34"> |
| <metadata> |
| <title>HTMLElement34</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the BDO element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"bdo"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"BDO Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement35.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement35"> |
| <metadata> |
| <title>HTMLElement35</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the TT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tt"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"TT Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement36.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement36"> |
| <metadata> |
| <title>HTMLElement36</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the I element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"i"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"I Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement37.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement37"> |
| <metadata> |
| <title>HTMLElement37</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the B element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"b"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"B Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement38.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement38"> |
| <metadata> |
| <title>HTMLElement38</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the U element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"u"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"U Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement39.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement39"> |
| <metadata> |
| <title>HTMLElement39</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the S element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"s"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"S Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement40.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement40"> |
| <metadata> |
| <title>HTMLElement40</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the STRIKE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"strike"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"STRIKE Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement41.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement41"> |
| <metadata> |
| <title>HTMLElement41</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the BIG element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"big"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"BIG Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement42.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement42"> |
| <metadata> |
| <title>HTMLElement42</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the SMALL element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"small"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"SMALL Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement43.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement43"> |
| <metadata> |
| <title>HTMLElement43</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the EM element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"em"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"EM Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement44.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement44"> |
| <metadata> |
| <title>HTMLElement44</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the STRONG element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"strong"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"STRONG Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement45.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement45"> |
| <metadata> |
| <title>HTMLElement45</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the DFN element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dfn"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"DFN Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement46.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement46"> |
| <metadata> |
| <title>HTMLElement46</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the CODE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"code"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"CODE Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement47.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement47"> |
| <metadata> |
| <title>HTMLElement47</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the SAMP element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"samp"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"SAMP Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement48.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement48"> |
| <metadata> |
| <title>HTMLElement48</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the KBD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"kbd"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"KBD Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement49.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement49"> |
| <metadata> |
| <title>HTMLElement49</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the VAR element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"var"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"VAR Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement50.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement50"> |
| <metadata> |
| <title>HTMLElement50</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the CITE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"cite"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"CITE Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement51.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement51"> |
| <metadata> |
| <title>HTMLElement51</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the ACRONYM element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"acronym"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"ACRONYM Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement52.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement52"> |
| <metadata> |
| <title>HTMLElement52</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the ABBR element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"abbr"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"ABBR Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement53.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement53"> |
| <metadata> |
| <title>HTMLElement53</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the DD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dd"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"DD Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement54.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement54"> |
| <metadata> |
| <title>HTMLElement54</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the DT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dt"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"DT Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement55.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement55"> |
| <metadata> |
| <title>HTMLElement55</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the NOFRAMES element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"noframes"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"NOFRAMES Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement56.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement56"> |
| <metadata> |
| <title>HTMLElement56</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the NOSCRIPT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"noscript"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"NOSCRIPT Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement57.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement57"> |
| <metadata> |
| <title>HTMLElement57</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the ADDRESS element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"address"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"ADDRESS Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement58.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement58"> |
| <metadata> |
| <title>HTMLElement58</title> |
| <creator>NIST</creator> |
| <description> |
| The title attribute specifies the elements advisory title. |
| Retrieve the title attribute of the CENTER element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78276800"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"center"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <title interface="HTMLElement" obj="testNode" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"CENTER Element"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement59.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement59"> |
| <metadata> |
| <title>HTMLElement59</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the HEAD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"head"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement60.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement60"> |
| <metadata> |
| <title>HTMLElement60</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the SUB element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"sub"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement61.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement61"> |
| <metadata> |
| <title>HTMLElement61</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the SUP element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"sup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement62.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement62"> |
| <metadata> |
| <title>HTMLElement62</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the SPAN element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"span"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement63.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement63"> |
| <metadata> |
| <title>HTMLElement63</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the BDO element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"bdo"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement64.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement64"> |
| <metadata> |
| <title>HTMLElement64</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the TT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tt"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement65.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement65"> |
| <metadata> |
| <title>HTMLElement65</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the I element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"i"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement66.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement66"> |
| <metadata> |
| <title>HTMLElement66</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the B element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"b"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement67.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement67"> |
| <metadata> |
| <title>HTMLElement67</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the U element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"u"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement68.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement68"> |
| <metadata> |
| <title>HTMLElement68</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the S element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"s"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement69.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement69"> |
| <metadata> |
| <title>HTMLElement69</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the STRIKE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"strike"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement70.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement70"> |
| <metadata> |
| <title>HTMLElement70</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the BIG element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"big"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement71.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement71"> |
| <metadata> |
| <title>HTMLElement71</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the SMALL element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"small"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement72.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement72"> |
| <metadata> |
| <title>HTMLElement72</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the EM element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"em"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement73.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement73"> |
| <metadata> |
| <title>HTMLElement73</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the STRONG element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"strong"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement74.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement74"> |
| <metadata> |
| <title>HTMLElement74</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the DFN element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dfn"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement75.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement75"> |
| <metadata> |
| <title>HTMLElement75</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the CODE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"code"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement76.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement76"> |
| <metadata> |
| <title>HTMLElement76</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the SAMP element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"samp"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement77.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement77"> |
| <metadata> |
| <title>HTMLElement77</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the KBD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"kbd"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement78.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement78"> |
| <metadata> |
| <title>HTMLElement78</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the VAR element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"var"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement79.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement79"> |
| <metadata> |
| <title>HTMLElement79</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the CITE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"cite"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement80.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement80"> |
| <metadata> |
| <title>HTMLElement80</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the ACRONYM element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"acronym"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement81.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement81"> |
| <metadata> |
| <title>HTMLElement81</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the ABBR element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"abbr"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement82.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement82"> |
| <metadata> |
| <title>HTMLElement82</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the DD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dd"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement83.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement83"> |
| <metadata> |
| <title>HTMLElement83</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the DT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dt"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement84.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement84"> |
| <metadata> |
| <title>HTMLElement84</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the NOFRAMES element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"noframes"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement85.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement85"> |
| <metadata> |
| <title>HTMLElement85</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the NOSCRIPT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"noscript"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement86.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement86"> |
| <metadata> |
| <title>HTMLElement86</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the ADDRESS element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"address"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement87.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement87"> |
| <metadata> |
| <title>HTMLElement87</title> |
| <creator>NIST</creator> |
| <description> |
| The lang attribute specifies the language code defined in RFC 1766. |
| Retrieve the lang attribute of the CENTER element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59132807"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlang" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"center"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lang interface="HTMLElement" obj="testNode" var="vlang"/> |
| <assertEquals actual="vlang" expected='"en"' id="langLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement88.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement88"> |
| <metadata> |
| <title>HTMLElement88</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the HEAD element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"head"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement89.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement89"> |
| <metadata> |
| <title>HTMLElement89</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the SUB element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"sub"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement90.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement90"> |
| <metadata> |
| <title>HTMLElement90</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the SUP element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"sup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement91.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement91"> |
| <metadata> |
| <title>HTMLElement91</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the SPAN element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"span"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement92.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement92"> |
| <metadata> |
| <title>HTMLElement92</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the BDO element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"bdo"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement93.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement93"> |
| <metadata> |
| <title>HTMLElement93</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the TT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tt"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement94.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement94"> |
| <metadata> |
| <title>HTMLElement94</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the I element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"i"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement95.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement95"> |
| <metadata> |
| <title>HTMLElement95</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the B element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"b"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement96.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement96"> |
| <metadata> |
| <title>HTMLElement96</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the U element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"u"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement97.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement97"> |
| <metadata> |
| <title>HTMLElement97</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the S element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"s"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement98.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement98"> |
| <metadata> |
| <title>HTMLElement98</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the STRIKE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"strike"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLElement99.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLElement99"> |
| <metadata> |
| <title>HTMLElement99</title> |
| <creator>NIST</creator> |
| <description> |
| The dir attribute specifies the base direction of directionally neutral text and the directionality of tables. |
| Retrieve the dir attribute of the BIG element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52460740"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdir" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="element" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"big"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dir interface="HTMLElement" obj="testNode" var="vdir"/> |
| <assertEquals actual="vdir" expected='"ltr"' id="dirLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFieldSetElement01.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFieldSetElement01"> |
| <metadata> |
| <title>HTMLFieldSetElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns the FORM element containing this control. |
| Retrieve the form attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-75392630"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="DOMString" /> |
| <var name="fNode" type="HTMLFormElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="fieldset" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"fieldset"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLFieldSetElement" obj="testNode" var="fNode"/> |
| <id obj="fNode" var="vform"/> |
| <assertEquals actual="vform" expected='"form2"' id="formLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFieldSetElement02.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFieldSetElement02"> |
| <metadata> |
| <title>HTMLFieldSetElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns null if control in not within the context of |
| form. |
| Retrieve the form attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-75392630"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="HTMLFormElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="fieldset" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"fieldset"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <form interface="HTMLFieldSetElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formNullLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFontElement01.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFontElement01"> |
| <metadata> |
| <title>HTMLFontElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The color attribute specifies the font's color. |
| Retrieve the color attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-53532975"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcolor" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="font" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"font"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <color interface="HTMLFontElement" obj="testNode" var="vcolor"/> |
| <assertEquals actual="vcolor" expected='"#000000"' id="colorLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFontElement02.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFontElement02"> |
| <metadata> |
| <title>HTMLFontElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The face attribute specifies the font's face identifier. |
| Retrieve the face attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-55715655"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#HTML-HTMLFormElement-length"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vface" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="font" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"font"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <face interface="HTMLFontElement" obj="testNode" var="vface"/> |
| <assertEquals actual="vface" expected='"arial,helvetica"' id="faceLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFontElement03.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFontElement03"> |
| <metadata> |
| <title>HTMLFontElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The size attribute specifies the font's size. |
| Retrieve the size attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-90127284"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsize" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="font" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"font"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <size interface="HTMLFontElement" obj="testNode" var="vsize"/> |
| <assertEquals actual="vsize" expected='"4"' id="sizeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFormElement01.xml.int-broken |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFormElement01"> |
| <metadata> |
| <title>HTMLFormElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The elements attribute specifies a collection of all control element |
| in the form. |
| Retrieve the elements attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-76728479"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="elementnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="velements" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="form" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <elements interface="HTMLFormElement" obj="testNode" var="elementnodeList"/> |
| <length interface="HTMLCollection" obj="elementnodeList" var="velements"/> |
| <assertEquals actual="velements" expected="3" id="elementsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFormElement02.xml.int-broken |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFormElement02"> |
| <metadata> |
| <title>HTMLFormElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The length attribute specifies the number of form controls |
| in the form. |
| Retrieve the length attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-40002357"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#HTML-HTMLFormElement-length"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlength" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="form" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <length interface="HTMLFormElement" obj="testNode" var="vlength"/> |
| <assertEquals actual="vlength" expected="3" id="lengthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFormElement03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFormElement03"> |
| <metadata> |
| <title>HTMLFormElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The id(name) attribute specifies the name of the form. |
| Retrieve the id attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-22051454"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="form" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <id obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"form1"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFormElement04.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFormElement04"> |
| <metadata> |
| <title>HTMLFormElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The acceptCharset attribute specifies the list of character sets |
| supported by the server. |
| Retrieve the acceptCharset attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-19661795"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vacceptcharset" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="form" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <acceptCharset interface="HTMLFormElement" obj="testNode" var="vacceptcharset"/> |
| <assertEquals actual="vacceptcharset" expected='"US-ASCII"' id="acceptCharsetLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFormElement05.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFormElement05"> |
| <metadata> |
| <title>HTMLFormElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The action attribute specifies the server-side form handler. |
| Retrieve the action attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-74049184"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaction" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="form" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <action interface="HTMLFormElement" obj="testNode" var="vaction"/> |
| <assertURIEquals actual="vaction" file='"getData.pl"' id="actionLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFormElement06.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFormElement06"> |
| <metadata> |
| <title>HTMLFormElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The enctype attribute specifies the content of the submitted form. |
| Retrieve the enctype attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-84227810"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="venctype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="form" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <enctype interface="HTMLFormElement" obj="testNode" var="venctype"/> |
| <assertEquals actual="venctype" expected='"application/x-www-form-urlencoded"' id="enctypeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFormElement07.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFormElement07"> |
| <metadata> |
| <title>HTMLFormElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The method attribute specifies the HTTP method used to submit the form. |
| Retrieve the method attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-82545539"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vmethod" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="form" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <method interface="HTMLFormElement" obj="testNode" var="vmethod"/> |
| <assertEquals actual="vmethod" expected='"post"' id="methodLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFormElement08.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFormElement08"> |
| <metadata> |
| <title>HTMLFormElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The target attribute specifies the frame to render the resource in. |
| Retrieve the target attribute and examine it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6512890"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtarget" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="form2" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <target interface="HTMLFormElement" obj="testNode" var="vtarget"/> |
| <assertEquals actual="vtarget" expected='"dynamic"' id="targetLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFormElement09.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFormElement09"> |
| <metadata> |
| <title>HTMLFormElement09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| HTMLFormElement.reset restores the forms default values. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-76767677"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="form2" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <reset interface="HTMLFormElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFormElement10.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFormElement10"> |
| <metadata> |
| <title>HTMLFormElement10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| HTMLFormElement.submit submits the form. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-76767676"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="form3" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <submit interface="HTMLFormElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFrameElement01.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFrameElement01"> |
| <metadata> |
| <title>HTMLFrameElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The frameBorder attribute specifies the request for frame borders. |
| (frameBorder=1 A border is drawn) |
| (FrameBorder=0 A border is not drawn) |
| Retrieve the frameBorder attribute of the first FRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-11858633"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vframeborder" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frame" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"frame"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <frameBorder interface="HTMLFrameElement" obj="testNode" var="vframeborder"/> |
| <assertEquals actual="vframeborder" expected='"1"' id="frameborderLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFrameElement02.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFrameElement02"> |
| <metadata> |
| <title>HTMLFrameElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The longDesc attribute specifies a URI designating a long description |
| of this image or frame. |
| Retrieve the longDesc attribute of the first FRAME element and examine |
| its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-7836998"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlongdesc" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frame" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"frame"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <longDesc interface="HTMLFrameElement" obj="testNode" var="vlongdesc"/> |
| <assertEquals actual="vlongdesc" expected='"about:blank"' ignoreCase="false" id="longdescLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFrameElement03.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFrameElement03"> |
| <metadata> |
| <title>HTMLFrameElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The marginHeight attribute specifies the frame margin height, in pixels. |
| Retrieve the marginHeight attribute of the first FRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-55569778"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vmarginheight" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frame" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"frame"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <marginHeight interface="HTMLFrameElement" obj="testNode" var="vmarginheight"/> |
| <assertEquals actual="vmarginheight" expected='"10"' id="marginheightLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFrameElement04.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFrameElement04"> |
| <metadata> |
| <title>HTMLFrameElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The marginWidth attribute specifies the frame margin width, in pixels. |
| Retrieve the marginWidth attribute of the first FRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-8369969"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vmarginwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frame" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"frame"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <marginWidth interface="HTMLFrameElement" obj="testNode" var="vmarginwidth"/> |
| <assertEquals actual="vmarginwidth" expected='"5"' id="marginwidthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFrameElement05.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFrameElement05"> |
| <metadata> |
| <title>HTMLFrameElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute specifies the frame name(object of the target |
| attribute). |
| Retrieve the name attribute of the first FRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-91128709"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frame" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"frame"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLFrameElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"Frame1"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFrameElement06.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFrameElement06"> |
| <metadata> |
| <title>HTMLFrameElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The noResize attribute specifies if the user can resize the frame. When |
| true, forbid user from resizing frame. |
| Retrieve the noResize attribute of the first FRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-80766578"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vnoresize" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frame" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"frame"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <noResize interface="HTMLFrameElement" obj="testNode" var="vnoresize"/> |
| <assertTrue actual="vnoresize" id="noresizeLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFrameElement07.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFrameElement07"> |
| <metadata> |
| <title>HTMLFrameElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The scrolling attribute specifies whether or not the frame should have |
| scrollbars. |
| Retrieve the scrolling attribute of the first FRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-45411424"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vscrolling" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frame" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"frame"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <scrolling interface="HTMLFrameElement" obj="testNode" var="vscrolling"/> |
| <assertEquals actual="vscrolling" expected='"yes"' id="scrollingLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFrameElement08.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFrameElement08"> |
| <metadata> |
| <title>HTMLFrameElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The src attribute specifies a URI designating the initial frame contents. |
| Retrieve the src attribute of the first FRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78799535"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsrc" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frame" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"frame"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <src interface="HTMLFrameElement" obj="testNode" var="vsrc"/> |
| <assertURIEquals actual="vsrc" name='"right"' id="srcLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFrameSetElement01.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFrameSetElement01"> |
| <metadata> |
| <title>HTMLFrameSetElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The cols attribute specifies the number of columns of frames in the |
| frameset. |
| Retrieve the cols attribute of the first FRAMESET element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-98869594"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcols" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frameset" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"frameset"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <cols interface="HTMLFrameSetElement" obj="testNode" var="vcols"/> |
| <assertEquals actual="vcols" expected='"20, 80"' id="colsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLFrameSetElement02.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLFrameSetElement02"> |
| <metadata> |
| <title>HTMLFrameSetElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The rows attribute specifies the number of rows of frames in the |
| frameset. |
| Retrieve the rows attribute of the second FRAMESET element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-19739247"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrows" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frameset" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"frameset"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLFrameSetElement" obj="testNode" var="vrows"/> |
| <assertEquals actual="vrows" expected='"100, 200"' id="rowsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHRElement01.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHRElement01"> |
| <metadata> |
| <title>HTMLHRElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the rule alignment on the page. |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-15235012"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="hr" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"hr"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLHRElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHRElement02.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHRElement02"> |
| <metadata> |
| <title>HTMLHRElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The noShade attribute specifies that the rule should be drawn as |
| a solid color. |
| Retrieve the noShade attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-79813978"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vnoshade" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="hr" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"hr"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <noShade interface="HTMLHRElement" obj="testNode" var="vnoshade"/> |
| <assertTrue actual="vnoshade" id="noShadeLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHRElement03.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHRElement03"> |
| <metadata> |
| <title>HTMLHRElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The size attribute specifies the height of the rule. |
| Retrieve the size attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-77612587"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsize" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="hr" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"hr"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <size interface="HTMLHRElement" obj="testNode" var="vsize"/> |
| <assertEquals actual="vsize" expected='"5"' id="sizeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHRElement04.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHRElement04"> |
| <metadata> |
| <title>HTMLHRElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute specifies the width of the rule. |
| Retrieve the width attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87744198"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="hr" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"hr"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLHRElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"400"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHeadElement01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHeadElement01"> |
| <metadata> |
| <title>HTMLHeadElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The profile attribute specifies a URI designating a metadata profile. |
| Retrieve the profile attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-96921909"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vprofile" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="head" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"head"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <profile interface="HTMLHeadElement" obj="testNode" var="vprofile"/> |
| <assertURIEquals actual="vprofile" file='"profile"' id="profileLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHeadingElement01.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHeadingElement01"> |
| <metadata> |
| <title>HTMLHeadingElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal text alignment(H1). |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6796462"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="heading" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"h1"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLHeadingElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHeadingElement02.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHeadingElement02"> |
| <metadata> |
| <title>HTMLHeadingElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal text alignment(H2). |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6796462"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="heading" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"h2"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLHeadingElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"left"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHeadingElement03.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHeadingElement03"> |
| <metadata> |
| <title>HTMLHeadingElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal text alignment(H3). |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6796462"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="heading" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"h3"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLHeadingElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"right"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHeadingElement04.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHeadingElement04"> |
| <metadata> |
| <title>HTMLHeadingElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal text alignment(H4). |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6796462"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="heading" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"h4"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLHeadingElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"justify"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHeadingElement05.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHeadingElement05"> |
| <metadata> |
| <title>HTMLHeadingElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal text alignment(H5). |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6796462"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="heading" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"h5"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLHeadingElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHeadingElement06.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHeadingElement06"> |
| <metadata> |
| <title>HTMLHeadingElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal text alignment(H6). |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6796462"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="heading" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"h6"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLHeadingElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"left"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLHtmlElement01.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLHtmlElement01"> |
| <metadata> |
| <title>HTMLHtmlElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The version attribute specifies version information about the document's |
| DTD. |
| Retrieve the version attribute and examine its value. |
| Test is only applicable to HTML, version attribute is not supported in XHTML. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-9383775"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vversion" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="html" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"html"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <version interface="HTMLHtmlElement" obj="testNode" var="vversion"/> |
| <if><contentType type="text/html"/> |
| <assertEquals actual="vversion" expected='"-//W3C//DTD HTML 4.01 Transitional//EN"' id="versionLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIFrameElement01.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIFrameElement01"> |
| <metadata> |
| <title>HTMLIFrameElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute aligns this object(vertically or horizontally with |
| respect to its surrounding text. |
| Retrieve the align attribute of the first IFRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-11309947"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"iframe"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLIFrameElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"top"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIFrameElement02.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIFrameElement02"> |
| <metadata> |
| <title>HTMLIFrameElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The frameBorder attribute specifies the request for frame borders. |
| (frameBorder=1 A border is drawn) |
| (FrameBorder=0 A border is not drawn) |
| Retrieve the frameBorder attribute of the first IFRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-22463410"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vframeborder" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"iframe"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <frameBorder interface="HTMLIFrameElement" obj="testNode" var="vframeborder"/> |
| <assertEquals actual="vframeborder" expected='"1"' id="frameborderLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIFrameElement03.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIFrameElement03"> |
| <metadata> |
| <title>HTMLIFrameElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The height attribute specifies the frame height. |
| Retrieve the height attribute of the first IFRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-1678118"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheight" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"iframe"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <height interface="HTMLIFrameElement" obj="testNode" var="vheight"/> |
| <assertEquals actual="vheight" expected='"50"' id="heightLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIFrameElement04.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIFrameElement04"> |
| <metadata> |
| <title>HTMLIFrameElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The longDesc attribute specifies a URI designating a long description |
| of this image or frame. |
| Retrieve the longDesc attribute of the first IFRAME element and examine |
| its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-70472105"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlongdesc" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"iframe"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <longDesc interface="HTMLIFrameElement" obj="testNode" var="vlongdesc"/> |
| <assertEquals actual="vlongdesc" expected='"about:blank"' ignoreCase="false" id="longdescLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIFrameElement05.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIFrameElement05"> |
| <metadata> |
| <title>HTMLIFrameElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The marginWidth attribute specifies the frame margin width, in pixels. |
| Retrieve the marginWidth attribute of the first FRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-66486595"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vmarginwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"iframe"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <marginWidth interface="HTMLIFrameElement" obj="testNode" var="vmarginwidth"/> |
| <assertEquals actual="vmarginwidth" expected='"5"' id="marginwidthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIFrameElement06.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIFrameElement06"> |
| <metadata> |
| <title>HTMLIFrameElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The marginHeight attribute specifies the frame margin height, in pixels. |
| Retrieve the marginHeight attribute of the first IFRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-91371294"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vmarginheight" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"iframe"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <marginHeight interface="HTMLIFrameElement" obj="testNode" var="vmarginheight"/> |
| <assertEquals actual="vmarginheight" expected='"10"' id="marginheightLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIFrameElement07.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIFrameElement07"> |
| <metadata> |
| <title>HTMLIFrameElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute specifies the frame name(object of the target |
| attribute). |
| Retrieve the name attribute of the first IFRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-96819659"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"iframe"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLIFrameElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"Iframe1"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIFrameElement08.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIFrameElement08"> |
| <metadata> |
| <title>HTMLIFrameElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The scrolling attribute specifies whether or not the frame should have |
| scrollbars. |
| Retrieve the scrolling attribute of the first FRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-36369822"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vscrolling" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"iframe"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <scrolling interface="HTMLIFrameElement" obj="testNode" var="vscrolling"/> |
| <assertEquals actual="vscrolling" expected='"yes"' id="scrollingLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIFrameElement09.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIFrameElement09"> |
| <metadata> |
| <title>HTMLIFrameElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The src attribute specifies a URI designating the initial frame contents. |
| Retrieve the src attribute of the first FRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-43933957"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsrc" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"iframe"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <src interface="HTMLIFrameElement" obj="testNode" var="vsrc"/> |
| <assertURIEquals actual="vsrc" name='"right"' id="srcLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIFrameElement10.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIFrameElement10"> |
| <metadata> |
| <title>HTMLIFrameElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute specifies the frame width. |
| Retrieve the width attribute of the first IFRAME element and examine |
| it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-67133005"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"iframe"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLIFrameElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"60"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement01.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement01"> |
| <metadata> |
| <title>HTMLImageElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute specifies the name of the element. |
| Retrieve the name attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-47534097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLImageElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"IMAGE-1"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement02.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement02"> |
| <metadata> |
| <title>HTMLImageElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute aligns this object with respect to its surrounding |
| text. |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-3211094"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLImageElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"middle"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement03.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement03"> |
| <metadata> |
| <title>HTMLImageElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The alt attribute specifies an alternative text for user agenst not |
| rendering the normal content of this element. |
| Retrieve the alt attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95636861"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valt" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <alt interface="HTMLImageElement" obj="testNode" var="valt"/> |
| <assertEquals actual="valt" expected='"DTS IMAGE LOGO"' id="altLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement04.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement04"> |
| <metadata> |
| <title>HTMLImageElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The border attribute specifies the width of the border around the image. |
| Retrieve the border attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-136671"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vborder" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <border interface="HTMLImageElement" obj="testNode" var="vborder"/> |
| <assertEquals actual="vborder" expected='"0"' id="borderLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement05.xml.kfail |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement05"> |
| <metadata> |
| <title>HTMLImageElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The height attribute overrides the natural "height" of the image. Retrieve the height attribute and examine its value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-91561496"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheight" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <height interface="HTMLImageElement" obj="testNode" var="vheight"/> |
| <assertEquals actual="vheight" expected='"47"' id="heightLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement06.xml.kfail |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement06"> |
| <metadata> |
| <title>HTMLImageElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The hspace attribute specifies the horizontal space to the left and |
| right of this image. |
| Retrieve the hspace attribute and examine its value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-53675471"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhspace" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <hspace interface="HTMLImageElement" obj="testNode" var="vhspace"/> |
| <assertEquals actual="vhspace" expected='"4"' id="hspaceLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement07.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement07"> |
| <metadata> |
| <title>HTMLImageElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The isMap attribute indicates the use of server-side image map. |
| Retrieve the isMap attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-58983880"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vismap" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <isMap interface="HTMLImageElement" obj="testNode" var="vismap"/> |
| <assertFalse actual="vismap" id="isMapLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement08.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement08"> |
| <metadata> |
| <title>HTMLImageElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The longDesc attribute contains an URI designating a long description |
| of this image or frame. |
| Retrieve the longDesc attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-77376969"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlongdesc" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <longDesc interface="HTMLImageElement" obj="testNode" var="vlongdesc"/> |
| <assertURIEquals actual="vlongdesc" file='"desc.html"' id="longDescLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement09.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement09"> |
| <metadata> |
| <title>HTMLImageElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The src attribute contains an URI designating the source of this image. |
| Retrieve the src attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87762984"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsrc" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <src interface="HTMLImageElement" obj="testNode" var="vsrc"/> |
| <assertURIEquals actual="vsrc" file='"dts.gif"' id="srcLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement10.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement10"> |
| <metadata> |
| <title>HTMLImageElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The useMap attribute specifies to use the client-side image map. |
| Retrieve the useMap attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-35981181"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vusemap" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <useMap interface="HTMLImageElement" obj="testNode" var="vusemap"/> |
| <assertEquals actual="vusemap" expected='"#DTS-MAP"' id="useMapLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement11.xml.kfail |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement11"> |
| <metadata> |
| <title>HTMLImageElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The vspace attribute specifies the vertical space above and below this |
| image. |
| Retrieve the vspace attribute and examine its value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-85374897"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvspace" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vspace interface="HTMLImageElement" obj="testNode" var="vvspace"/> |
| <assertEquals actual="vvspace" expected='"10"' id="vspaceLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement12.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement12"> |
| <metadata> |
| <title>HTMLImageElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute overrides the natural "width" of the image. |
| Retrieve the width attribute and examine its value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-13839076"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLImageElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"115"' id="widthLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLImageElement14.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLImageElement14"> |
| <metadata> |
| <title>HTMLImageElement14</title> |
| <creator>NIST</creator> |
| <description> |
| The lowSrc attribute specifies an URI designating a long description of |
| this image or frame. |
| Retrieve the lowSrc attribute of the first IMG element and examine |
| its value. Should be "" since lowSrc is not a valid attribute for IMG. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-19</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-91256910"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlow" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"img"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <lowSrc interface="HTMLImageElement" obj="testNode" var="vlow"/> |
| <assertEquals actual="vlow" expected='""' id="lowLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement01.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement01"> |
| <metadata> |
| <title>HTMLInputElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The defaultValue attribute represents the HTML value of the attribute |
| when the type attribute has the value of "Text", "File" or "Password". |
| Retrieve the defaultValue attribute of the 1st INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-26091157"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdefaultvalue" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <defaultValue interface="HTMLInputElement" obj="testNode" var="vdefaultvalue"/> |
| <assertEquals actual="vdefaultvalue" expected='"Password"' id="defaultValueLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement02.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement02"> |
| <metadata> |
| <title>HTMLInputElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The defaultChecked attribute represents the HTML checked attribute of |
| the element when the type attribute has the value checkbox or radio. |
| Retrieve the defaultValue attribute of the 4th INPUT element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-20509171"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdefaultchecked" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <defaultChecked interface="HTMLInputElement" obj="testNode" var="vdefaultchecked"/> |
| <assertTrue actual="vdefaultchecked" id="defaultCheckedLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement03.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement03"> |
| <metadata> |
| <title>HTMLInputElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns the FORM element containing this control. |
| Retrieve the form attribute of the 1st INPUT element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63239895"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="DOMString" /> |
| <var name="fNode" type="HTMLFormElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLInputElement" obj="testNode" var="fNode"/> |
| <id obj="fNode" var="vform"/> |
| <assertEquals actual="vform" expected='"form1"' id="formLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement04.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement04"> |
| <metadata> |
| <title>HTMLInputElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The accept attribute is a comma-seperated list of content types that |
| a server processing this form will handle correctly. |
| Retrieve the accept attribute of the 9th INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-15328520"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaccept" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="8"/> |
| <accept interface="HTMLInputElement" obj="testNode" var="vaccept"/> |
| <assertEquals actual="vaccept" expected='"GIF,JPEG"' id="acceptLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement05.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement05"> |
| <metadata> |
| <title>HTMLInputElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The accessKey attribute is a single character access key to give access |
| to the form control. |
| Retrieve the accessKey attribute of the 2nd INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59914154"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaccesskey" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <accessKey interface="HTMLInputElement" obj="testNode" var="vaccesskey"/> |
| <assertEquals actual="vaccesskey" expected='"c"' id="accesskeyLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement06.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement06"> |
| <metadata> |
| <title>HTMLInputElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute aligns this object(vertically or horizontally) |
| with respect to the surrounding text. |
| Retrieve the align attribute of the 4th INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-96991182"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <align interface="HTMLInputElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"bottom"' id="alignLink" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement07.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement07"> |
| <metadata> |
| <title>HTMLInputElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The alt attribute alternates text for user agents not rendering the |
| normal content of this element. |
| Retrieve the alt attribute of the 1st INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-92701314"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valt" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <alt interface="HTMLInputElement" obj="testNode" var="valt"/> |
| <assertEquals actual="valt" expected='"Password entry"' id="altLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement08.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement08"> |
| <metadata> |
| <title>HTMLInputElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The checked attribute represents the current state of the corresponding |
| form control when type has the value Radio or Checkbox. |
| Retrieve the accept attribute of the 3rd INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-30233917"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vchecked" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="2"/> |
| <checked interface="HTMLInputElement" obj="testNode" var="vchecked"/> |
| <assertTrue actual="vchecked" id="checkedLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement09.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement09"> |
| <metadata> |
| <title>HTMLInputElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The disabled attribute has a TRUE value if it is explicitly set. |
| Retrieve the disabled attribute of the 7th INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-50886781"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdisabled" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="6"/> |
| <disabled interface="HTMLInputElement" obj="testNode" var="vdisabled"/> |
| <assertTrue actual="vdisabled" id="disabledLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement10.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement10"> |
| <metadata> |
| <title>HTMLInputElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The maxLength attribute is the maximum number of text characters for text |
| fields, when type has the value of Text or Password. |
| Retrieve the maxLenght attribute of the 1st INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-54719353"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vmaxlength" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <maxLength interface="HTMLInputElement" obj="testNode" var="vmaxlength"/> |
| <assertEquals actual="vmaxlength" expected="5" id="maxlengthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement11.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement11"> |
| <metadata> |
| <title>HTMLInputElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute is the form control or object name when submitted with |
| a form. |
| Retrieve the name attribute of the 1st INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-89658498"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLInputElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"Password"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement12.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement12"> |
| <metadata> |
| <title>HTMLInputElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The readOnly attribute indicates that this control is read-only when |
| type has a value of text or password only. |
| Retrieve the readOnly attribute of the 1st INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88461592"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vreadonly" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <readOnly interface="HTMLInputElement" obj="testNode" var="vreadonly"/> |
| <assertTrue actual="vreadonly" id="readonlyLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement13.xml.kfail |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement13"> |
| <metadata> |
| <title>HTMLInputElement13</title> |
| <creator>NIST</creator> |
| <description> |
| The size attribute contains the size information. Its precise meaning |
| is specific to each type of field. |
| Retrieve the size attribute of the 1st INPUT element and examine |
| its value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-79659438"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsize" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <size interface="HTMLInputElement" obj="testNode" var="vsize"/> |
| <assertEquals actual="vsize" expected='"25"' id="sizeLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement14.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement14"> |
| <metadata> |
| <title>HTMLInputElement14</title> |
| <creator>NIST</creator> |
| <description> |
| The src attribute specifies the location of the image to decorate the |
| graphical submit button when the type has the value Image. |
| Retrieve the src attribute of the 8th INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-97320704"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsrc" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="7"/> |
| <src interface="HTMLInputElement" obj="testNode" var="vsrc"/> |
| <assertURIEquals actual="vsrc" file='"submit.gif"' id="srcLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement15.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement15"> |
| <metadata> |
| <title>HTMLInputElement15</title> |
| <creator>NIST</creator> |
| <description> |
| The tabIndex attribute is an index that represents the elements position |
| in the tabbing order. |
| Retrieve the tabIndex attribute of the 3rd INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-62176355"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtabindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="2"/> |
| <tabIndex interface="HTMLInputElement" obj="testNode" var="vtabindex"/> |
| <assertEquals actual="vtabindex" expected="9" id="tabindexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement16.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement16"> |
| <metadata> |
| <title>HTMLInputElement16</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute is the type of control created. |
| Retrieve the type attribute of the 1st INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-62883744"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLInputElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"password"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement17.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement17"> |
| <metadata> |
| <title>HTMLInputElement17</title> |
| <creator>NIST</creator> |
| <description> |
| The useMap attribute specifies the use of the client-side image map. |
| Retrieve the useMap attribute of the 8th INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-32463706"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vusemap" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="7"/> |
| <useMap interface="HTMLInputElement" obj="testNode" var="vusemap"/> |
| <assertEquals actual="vusemap" expected='"#submit-map"' id="usemapLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement18.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement18"> |
| <metadata> |
| <title>HTMLInputElement18</title> |
| <creator>NIST</creator> |
| <description> |
| The value attribute is the current content of the corresponding form |
| control when the type attribute has the value Text, File or Password. |
| Retrieve the value attribute of the 2nd INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-49531485"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalue" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <value interface="HTMLInputElement" obj="testNode" var="vvalue"/> |
| <assertEquals actual="vvalue" expected='"ReHire"' id="valueLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement19.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement19"> |
| <metadata> |
| <title>HTMLInputElement19</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| HTMLInputElement.blur should surrender input focus. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-26838235"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <blur interface="HTMLInputElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement20.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement20"> |
| <metadata> |
| <title>HTMLInputElement20</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| HTMLInputElement.focus should capture input focus. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-65996295"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="input" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <focus interface="HTMLInputElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement21.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement21"> |
| <metadata> |
| <title>HTMLInputElement21</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| HTMLInputElement.click should change the state of checked on a radio button. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-2651361"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <var name="checked" type="boolean"/> |
| <load var="doc" href="input" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <checked var="checked" obj="testNode"/> |
| <assertFalse actual="checked" id="notCheckedBeforeClick"/> |
| <click interface="HTMLInputElement" obj="testNode"/> |
| <checked var="checked" obj="testNode"/> |
| <assertTrue actual="checked" id="checkedAfterClick"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLInputElement22.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLInputElement22"> |
| <metadata> |
| <title>HTMLInputElement22</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| HTMLInputElement.select should select the contents of a text area. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-34677168"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <var name="checked" type="boolean"/> |
| <load var="doc" href="input" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <select interface="HTMLInputElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIsIndexElement01.xml.kfail |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIsIndexElement01"> |
| <metadata> |
| <title>HTMLIsIndexElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns the FORM element containing this control. |
| Retrieve the form attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87069980"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="DOMString" /> |
| <var name="fNode" type="HTMLFormElement"/> |
| <var name="doc" type="Document"/> |
| <var name="prompt" type="DOMString"/> |
| <load var="doc" href="isindex" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"isindex"'/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <assertNotNull id="notnull" actual="testNode"/> |
| <!-- check contents of prompt --> |
| <prompt interface="HTMLIsIndexElement" var="prompt" obj="testNode"/> |
| <assertEquals id="IsIndex.Prompt" actual="prompt" expected='"New Employee: "' ignoreCase="false"/> |
| <form interface="HTMLIsIndexElement" obj="testNode" var="fNode"/> |
| <assertNotNull id="formNotNull" actual="fNode"/> |
| <id obj="fNode" var="vform"/> |
| <assertEquals actual="vform" expected='"form1"' id="formLink" ignoreCase="false"/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIsIndexElement02.xml.kfail |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIsIndexElement02"> |
| <metadata> |
| <title>HTMLIsIndexElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns null if control in not within the context of |
| form. |
| Retrieve the form attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87069980"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="HTMLFormElement" /> |
| <var name="doc" type="Document"/> |
| <var name="prompt" type="DOMString"/> |
| <load var="doc" href="isindex" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"isindex"'/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <assertNotNull id="notnull" actual="testNode"/> |
| <!-- check contents of prompt --> |
| <prompt interface="HTMLIsIndexElement" var="prompt" obj="testNode"/> |
| <assertEquals id="IsIndex.Prompt" actual="prompt" expected='"Old Employee: "' ignoreCase="false"/> |
| <!-- check form == null since not in context of a form --> |
| <form interface="HTMLIsIndexElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formNullLink"/> |
| <!-- check that we found 2 isindex elements --> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLIsIndexElement03.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLIsIndexElement03"> |
| <metadata> |
| <title>HTMLIsIndexElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The prompt attribute specifies the prompt message. |
| Retrieve the prompt attribute of the 1st isindex element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-33589862"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vprompt" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="isindex" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"isindex"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <prompt interface="HTMLIsIndexElement" obj="testNode" var="vprompt"/> |
| <assertEquals actual="vprompt" expected='"New Employee: "' id="promptLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLIElement01.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLIElement01"> |
| <metadata> |
| <title>HTMLLIElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute is a list item bullet style. |
| Retrieve the type attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52387668"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="li" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"li"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLLIElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"square"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLIElement02.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLIElement02"> |
| <metadata> |
| <title>HTMLLIElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The value attribute is a reset sequence number when used in OL. |
| Retrieve the value attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-45496263"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalue" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="li" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"li"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <value interface="HTMLLIElement" obj="testNode" var="vvalue"/> |
| <assertEquals actual="vvalue" expected="2" id="valueLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLabelElement01.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLabelElement01"> |
| <metadata> |
| <title>HTMLLabelElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns the FORM element containing this control. |
| Retrieve the form attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-32480901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="DOMString" /> |
| <var name="fNode" type="HTMLFormElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="label" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"label"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLLabelElement" obj="testNode" var="fNode"/> |
| <id obj="fNode" var="vform"/> |
| <assertEquals actual="vform" expected='"form1"' id="formLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLabelElement02.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLabelElement02"> |
| <metadata> |
| <title>HTMLLabelElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns null if control in not within the context of |
| form. |
| Retrieve the form attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-32480901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="HTMLFormElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="label" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"label"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <form interface="HTMLLabelElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formNullLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLabelElement03.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLabelElement03"> |
| <metadata> |
| <title>HTMLLabelElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The accessKey attribute is a single character access key to give access |
| to the form control. |
| Retrieve the accessKey attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-43589892"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaccesskey" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="label" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"label"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <accessKey interface="HTMLLabelElement" obj="testNode" var="vaccesskey"/> |
| <assertEquals actual="vaccesskey" expected='"b"' id="accesskeyLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLabelElement04.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLabelElement04"> |
| <metadata> |
| <title>HTMLLabelElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The htmlFor attribute links this label with another form control by |
| id attribute. |
| Retrieve the htmlFor attribute of the first LABEL element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-96509813"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhtmlfor" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="label" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"label"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <htmlFor interface="HTMLLabelElement" obj="testNode" var="vhtmlfor"/> |
| <assertEquals actual="vhtmlfor" expected='"input1"' id="htmlForLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLegendElement01.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLegendElement01"> |
| <metadata> |
| <title>HTMLLLegendElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns the FORM element containing this control. |
| Retrieve the form attribute from the first LEGEND element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-29594519"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="DOMString" /> |
| <var name="fNode" type="HTMLFormElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="legend" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"legend"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLLegendElement" obj="testNode" var="fNode"/> |
| <id obj="fNode" var="vform"/> |
| <assertEquals actual="vform" expected='"form1"' id="formLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLegendElement02.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLegendElement02"> |
| <metadata> |
| <title>HTMLLegendElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns null if control in not within the context of |
| form. |
| Retrieve the second ELEMENT and examine its form element. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-29594519"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="HTMLFormElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="legend" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"legend"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <form interface="HTMLLegendElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formNullLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLegendElement03.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLegendElement03"> |
| <metadata> |
| <title>HTMLLegendElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The accessKey attribute is a single character access key to give access |
| to the form control. |
| Retrieve the accessKey attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-11297832"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaccesskey" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="legend" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"legend"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <accessKey interface="HTMLLegendElement" obj="testNode" var="vaccesskey"/> |
| <assertEquals actual="vaccesskey" expected='"b"' id="accesskeyLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLegendElement04.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLegendElement04"> |
| <metadata> |
| <title>HTMLLegendElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the text alignment relative to FIELDSET. |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-79538067"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="legend" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"legend"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLLegendElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"top"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLinkElement01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLinkElement01"> |
| <metadata> |
| <title>HTMLLinkElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The disabled attribute enables/disables the link. |
| Retrieve the disabled attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87355129"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdisabled" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="link" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"link"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <disabled interface="HTMLLinkElement" obj="testNode" var="vdisabled"/> |
| <assertFalse actual="vdisabled" id="disabled"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLinkElement02.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLinkElement02"> |
| <metadata> |
| <title>HTMLLinkElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The charset attribute indicates the character encoding of the linked |
| resource. |
| Retrieve the charset attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63954491"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcharset" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="link" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"link"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <charset interface="HTMLLinkElement" obj="testNode" var="vcharset"/> |
| <assertEquals actual="vcharset" expected='"Latin-1"' id="charsetLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLinkElement03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLinkElement03"> |
| <metadata> |
| <title>HTMLLinkElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The href attribute specifies the URI of the linked resource. |
| Retrieve the href attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-33532588"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhref" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="link" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"link"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <href interface="HTMLLinkElement" obj="testNode" var="vhref"/> |
| <assertURIEquals actual="vhref" file='"glossary.html"' id="hrefLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLinkElement04.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLinkElement04"> |
| <metadata> |
| <title>HTMLLinkElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The hreflang attribute specifies the language code of the linked resource. |
| Retrieve the hreflang attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-85145682"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhreflang" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="link" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"link"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <hreflang interface="HTMLLinkElement" obj="testNode" var="vhreflang"/> |
| <assertEquals actual="vhreflang" expected='"en"' id="hreflangLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLinkElement05.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLinkElement05"> |
| <metadata> |
| <title>HTMLLinkElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The media attribute specifies the targeted media. |
| Retrieve the media attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-75813125"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vmedia" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="link" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"link"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <media interface="HTMLLinkElement" obj="testNode" var="vmedia"/> |
| <assertEquals actual="vmedia" expected='"screen"' id="mediaLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLinkElement06.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLinkElement06"> |
| <metadata> |
| <title>HTMLLinkElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The rel attribute specifies the forward link type. |
| Retrieve the rel attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-41369587"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrel" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="link" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"link"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rel interface="HTMLLinkElement" obj="testNode" var="vrel"/> |
| <assertEquals actual="vrel" expected='"Glossary"' id="relLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLinkElement07.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLinkElement07"> |
| <metadata> |
| <title>HTMLLinkElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The rev attribute specifies the reverse link type. |
| Retrieve the rev attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-40715461"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrev" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="link" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"link"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rev interface="HTMLLinkElement" obj="testNode" var="vrev"/> |
| <assertEquals actual="vrev" expected='"stylesheet"' id="revLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLinkElement08.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLinkElement08"> |
| <metadata> |
| <title>HTMLLinkElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute specifies the advisory content type. |
| Retrieve the type attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-32498296"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="link" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"link"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLLinkElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"text/html"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLLinkElement09.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLLinkElement09"> |
| <metadata> |
| <title>HTMLLinkElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The target attribute specifies the frame to render the resource in. |
| Retrieve the target attribute and examine it's value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-84183095"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtarget" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="link2" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"link"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <target interface="HTMLLinkElement" obj="testNode" var="vtarget"/> |
| <assertEquals actual="vtarget" expected='"dynamic"' id="targetLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLMapElement01.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLMapElement01"> |
| <metadata> |
| <title>HTMLMapElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The areas attribute is a list of areas defined for the image map. |
| Retrieve the areas attribute and find the number of areas defined. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-71838730"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="areasnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="vareas" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="map" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"map"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <areas interface="HTMLMapElement" obj="testNode" var="areasnodeList"/> |
| <length interface="HTMLCollection" obj="areasnodeList" var="vareas"/> |
| <assertEquals actual="vareas" expected="3" id="areasLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLMapElement02.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLMapElement02"> |
| <metadata> |
| <title>HTMLMapElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute names the map(for use with usemap). |
| Retrieve the name attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52696514"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="map" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"map"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLMapElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"mapid"' id="mapLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLMenuElement01.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLMenuElement01"> |
| <metadata> |
| <title>HTMLMenuElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The compact attribute specifies a boolean value on whether to display |
| the list more compactly. |
| Retrieve the compact attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-68436464"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcompact" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="menu" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"menu"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <compact interface="HTMLMenuElement" obj="testNode" var="vcompact"/> |
| <assertTrue actual="vcompact" id="compactLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLMetaElement01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLMetaElement01"> |
| <metadata> |
| <title>HTMLMetaElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The content attribute specifies associated information. |
| Retrieve the content attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87670826"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcontent" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="meta" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"meta"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <content interface="HTMLMetaElement" obj="testNode" var="vcontent"/> |
| <assertEquals actual="vcontent" expected='"text/html; CHARSET=utf-8"' id="contentLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLMetaElement02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLMetaElement02"> |
| <metadata> |
| <title>HTMLMetaElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The httpEquiv attribute specifies an HTTP respnse header name. |
| Retrieve the httpEquiv attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-77289449"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhttpequiv" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="meta" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"meta"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <httpEquiv interface="HTMLMetaElement" obj="testNode" var="vhttpequiv"/> |
| <assertEquals actual="vhttpequiv" expected='"Content-Type"' id="httpEquivLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLMetaElement03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLMetaElement03"> |
| <metadata> |
| <title>HTMLMetaElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute specifies the meta information name. |
| Retrieve the name attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-31037081"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="meta" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"meta"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLMetaElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"Meta-Name"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLMetaElement04.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLMetaElement04"> |
| <metadata> |
| <title>HTMLMetaElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The scheme attribute specifies a select form of content. |
| Retrieve the scheme attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-35993789"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vscheme" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="meta" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"meta"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <scheme interface="HTMLMetaElement" obj="testNode" var="vscheme"/> |
| <assertEquals actual="vscheme" expected='"NIST"' id="schemeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLModElement01.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLModElement01"> |
| <metadata> |
| <title>HTMLModElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The cite attribute specifies an URI designating a document that describes |
| the reason for the change. |
| Retrieve the cite attribute of the INS element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-75101708"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcite" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="mod" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"ins"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <cite interface="HTMLModElement" obj="testNode" var="vcite"/> |
| <assertURIEquals actual="vcite" file='"ins-reasons.html"' id="citeLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLModElement02.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLModElement02"> |
| <metadata> |
| <title>HTMLModElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The dateTime attribute specifies the date and time of the change. |
| Retrieve the dateTime attribute of the INS element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88432678"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdatetime" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="mod" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"ins"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dateTime interface="HTMLModElement" obj="testNode" var="vdatetime"/> |
| <assertEquals actual="vdatetime" expected='"January 1, 2002"' id="dateTimeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLModElement03.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLModElement03"> |
| <metadata> |
| <title>HTMLModElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The cite attribute specifies an URI designating a document that describes |
| the reason for the change. |
| Retrieve the cite attribute of the DEL element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-75101708"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcite" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="mod" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"del"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <cite interface="HTMLModElement" obj="testNode" var="vcite"/> |
| <assertURIEquals actual="vcite" file='"del-reasons.html"' id="citeLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLModElement04.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLModElement04"> |
| <metadata> |
| <title>HTMLModElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The dateTime attribute specifies the date and time of the change. |
| Retrieve the dateTime attribute of the DEL element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88432678"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdatetime" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="mod" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"del"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <dateTime interface="HTMLModElement" obj="testNode" var="vdatetime"/> |
| <assertEquals actual="vdatetime" expected='"January 2, 2002"' id="dateTimeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOListElement01.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOListElement01"> |
| <metadata> |
| <title>HTMLOListElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The compact attribute specifies a boolean value on whether to display |
| the list more compactly. |
| Retrieve the compact attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-76448506"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcompact" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="olist" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"ol"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <compact interface="HTMLOListElement" obj="testNode" var="vcompact"/> |
| <assertTrue actual="vcompact" id="compactLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOListElement02.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOListElement02"> |
| <metadata> |
| <title>HTMLOListElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The start attribute specifies the starting sequence number. |
| Retrieve the start attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-14793325"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vstart" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="olist" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"ol"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <start interface="HTMLOListElement" obj="testNode" var="vstart"/> |
| <assertEquals actual="vstart" expected="1" id="startLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOListElement03.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOListElement03"> |
| <metadata> |
| <title>HTMLOListElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute specifies the numbering style. |
| Retrieve the type attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-40971103"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="olist" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"ol"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLOListElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"1"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement01.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement01"> |
| <metadata> |
| <title>HTMLObjectElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns the FORM element containing this control. |
| Retrieve the form attribute and examine its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-19</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-46094773"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="fNode" type="HTMLFormElement"/> |
| <var name="vform" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object2" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <form interface="HTMLObjectElement" obj="testNode" var="fNode"/> |
| <id obj="fNode" var="vform"/> |
| <assertEquals actual="vform" expected='"object2"' id="idLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement02.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement02"> |
| <metadata> |
| <title>HTMLObjectElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The code attribute specifies an Applet class file. |
| Retrieve the code attribute of the second OBJECT element and examine |
| its value. Should be "" since CODE is not a valid attribute for OBJECT. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-75241146"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcode" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <code interface="HTMLObjectElement" obj="testNode" var="vcode"/> |
| <assertEquals actual="vcode" expected='""' id="codeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement03.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement03"> |
| <metadata> |
| <title>HTMLObjectElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the alignment of this object with respect |
| to its surrounding text. |
| Retrieve the align attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-16962097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLObjectElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"middle"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement04.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement04"> |
| <metadata> |
| <title>HTMLObjectElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The archive attribute specifies a space-separated list of archives. |
| Retrieve the archive attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-47783837"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="varchive" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <archive interface="HTMLObjectElement" obj="testNode" var="varchive"/> |
| <assertEquals actual="varchive" expected='""' id="archiveLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement05.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement05"> |
| <metadata> |
| <title>HTMLObjectElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The border attribute specifies the widht of the border around the object. |
| Retrieve the border attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-82818419"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vborder" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <border interface="HTMLObjectElement" obj="testNode" var="vborder"/> |
| <assertEquals actual="vborder" expected='"0"' id="borderLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement06.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement06"> |
| <metadata> |
| <title>HTMLObjectElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The codeBase attribute specifies the base URI for the classid, data and |
| archive attributes. |
| Retrieve the codeBase attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-25709136"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcodebase" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <codeBase interface="HTMLObjectElement" obj="testNode" var="vcodebase"/> |
| <assertURIEquals actual="vcodebase" path='"//xw2k.sdct.itl.nist.gov/brady/dom/"' id="codebaseLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement07.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement07"> |
| <metadata> |
| <title>HTMLObjectElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The codeType attribute specifies the data downloaded via the classid |
| attribute. |
| Retrieve the codeType attribute of the second OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-19945008"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcodetype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <codeType interface="HTMLObjectElement" obj="testNode" var="vcodetype"/> |
| <assertEquals actual="vcodetype" expected='"image/gif"' id="codetypeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement08.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement08"> |
| <metadata> |
| <title>HTMLObjectElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The data attribute specifies the URI of the location of the objects data. |
| Retrieve the data attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-81766986"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdata" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <data interface="HTMLObjectElement" obj="testNode" var="vdata"/> |
| <assertURIEquals actual="vdata" file='"logo.gif"' id="dataLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement09.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement09"> |
| <metadata> |
| <title>HTMLObjectElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The declare attribute specifies this object should be declared only and |
| no instance of it should be created. |
| Retrieve the declare attribute of the second OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-942770"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdeclare" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <declare interface="HTMLObjectElement" obj="testNode" var="vdeclare"/> |
| <assertTrue actual="vdeclare" id="declareLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement10.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement10"> |
| <metadata> |
| <title>HTMLObjectElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The height attribute overrides the value of the actual height of the |
| object. |
| Retrieve the height attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88925838"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheight" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <height interface="HTMLObjectElement" obj="testNode" var="vheight"/> |
| <assertEquals actual="vheight" expected='"60"' id="heightLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement11.xml.kfail |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement11"> |
| <metadata> |
| <title>HTMLObjectElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The hspace attribute specifies the horizontal space to the left and right |
| of this image, applet or object. |
| Retrieve the hspace attribute of the first OBJECT element and examine |
| its value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-17085376"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhspace" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <hspace interface="HTMLObjectElement" obj="testNode" var="vhspace"/> |
| <assertEquals actual="vhspace" expected='"0"' id="hspaceLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement12.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement12"> |
| <metadata> |
| <title>HTMLObjectElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The standby attribute specifies a message to render while loading the |
| object. |
| Retrieve the standby attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-25039673"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vstandby" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <standby interface="HTMLObjectElement" obj="testNode" var="vstandby"/> |
| <assertEquals actual="vstandby" expected='"Loading Image ..."' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement13.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement13"> |
| <metadata> |
| <title>HTMLObjectElement13</title> |
| <creator>NIST</creator> |
| <description> |
| The tabIndex attribute specifies the elements position in the tabbing |
| order. |
| Retrieve the tabIndex attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-27083787"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtabindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tabIndex interface="HTMLObjectElement" obj="testNode" var="vtabindex"/> |
| <assertEquals actual="vtabindex" expected="0" id="tabIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement14.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement14"> |
| <metadata> |
| <title>HTMLObjectElement14</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute specifies the content type for data downloaded via |
| the data attribute. |
| Retrieve the type attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-91665621"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLObjectElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"image/gif"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement15.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement15"> |
| <metadata> |
| <title>HTMLObjectElement15</title> |
| <creator>NIST</creator> |
| <description> |
| The useMap attribute specifies the used client-side image map. |
| Retrieve the useMap attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6649772"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vusemap" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <useMap interface="HTMLObjectElement" obj="testNode" var="vusemap"/> |
| <assertEquals actual="vusemap" expected='"#DivLogo-map"' id="useMapLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement16.xml.kfail |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement16"> |
| <metadata> |
| <title>HTMLObjectElement16</title> |
| <creator>NIST</creator> |
| <description> |
| The vspace attribute specifies the vertical space above or below this |
| image, applet or object. |
| Retrieve the vspace attribute of the first OBJECT element and examine |
| its value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-8682483"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvspace" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vspace interface="HTMLObjectElement" obj="testNode" var="vvspace"/> |
| <assertEquals actual="vvspace" expected='"0"' id="vspaceLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement17.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement17"> |
| <metadata> |
| <title>HTMLObjectElement17</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute overrides the original width value. |
| Retrieve the width attribute of the first OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-38538620"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLObjectElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"550"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement18.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement18"> |
| <metadata> |
| <title>HTMLObjectElement18</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute specifies form control or object name when submitted |
| with a form. |
| Retrieve the name attribute of the second OBJECT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-20110362"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <name interface="HTMLObjectElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"OBJECT2"' id="vspaceLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLObjectElement19.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLObjectElement19"> |
| <metadata> |
| <title>HTMLObjectElement19</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns null if control in not within the context of |
| form. |
| Retrieve the form attribute and examine its value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-19</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-46094773"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="HTMLFormElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="object2" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLObjectElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formNullLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptGroupElement01.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptGroupElement01"> |
| <metadata> |
| <title>HTMLOptGroupElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The disabled attribute indicates that the control is unavailable in |
| this context. |
| Retrieve the disabled attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-15518803"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdisabled" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="optgroup" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"optgroup"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <disabled interface="HTMLOptGroupElement" obj="testNode" var="vdisabled"/> |
| <assertTrue actual="vdisabled" id="disabledLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptGroupElement02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptGroupElement02"> |
| <metadata> |
| <title>HTMLOptGroupElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The label attribute specifies the label assigned to this option group. |
| Retrieve the label attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-95806054"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlabel" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="optgroup" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"optgroup"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <label interface="HTMLOptGroupElement" obj="testNode" var="vlabel"/> |
| <assertEquals actual="vlabel" expected='"Regular Employees"' id="labelLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptionElement01.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptionElement01"> |
| <metadata> |
| <title>HTMLOptionElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns the FORM element containing this control. |
| Retrieve the form attribute from the first SELECT element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-17116503"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="DOMString" /> |
| <var name="fNode" type="HTMLFormElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="option" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"option"'/> |
| <assertSize collection="nodeList" size="10" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLOptionElement" obj="testNode" var="fNode"/> |
| <id obj="fNode" var="vform"/> |
| <assertEquals actual="vform" expected='"form1"' id="formLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptionElement02.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptionElement02"> |
| <metadata> |
| <title>HTMLOptionElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns null if control in not within the context of |
| a form. |
| Retrieve the first OPTION attribute from the second select element and |
| examine its form element. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-17116503"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="HTMLFormElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="option" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"option"'/> |
| <assertSize collection="nodeList" size="10" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="6"/> |
| <form interface="HTMLOptionElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formNullLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptionElement03.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptionElement03"> |
| <metadata> |
| <title>HTMLOptionElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The defaultSelected attribute contains the value of the selected |
| attribute. |
| Retrieve the defaultSelected attribute from the first OPTION element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-37770574"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdefaultselected" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="option" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"option"'/> |
| <assertSize collection="nodeList" size="10" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <defaultSelected interface="HTMLOptionElement" obj="testNode" var="vdefaultselected"/> |
| <assertTrue actual="vdefaultselected" id="defaultSelectedLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptionElement04.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptionElement04"> |
| <metadata> |
| <title>HTMLOptionElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The text attribute contains the text contained within the option element. |
| Retrieve the text attribute from the second OPTION element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-48154426"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtext" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="option" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"option"'/> |
| <assertSize collection="nodeList" size="10" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <text interface="HTMLOptionElement" obj="testNode" var="vtext"/> |
| <assertEquals actual="vtext" expected='"EMP10002"' id="textLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptionElement05.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptionElement05"> |
| <metadata> |
| <title>HTMLOptionElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The index attribute indicates th index of this OPTION in ints parent |
| SELECT. |
| Retrieve the index attribute from the seventh OPTION element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-14038413"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="option" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"option"'/> |
| <assertSize collection="nodeList" size="10" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="6"/> |
| <index interface="HTMLOptionElement" obj="testNode" var="vindex"/> |
| <assertEquals actual="vindex" expected="1" id="indexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptionElement06.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptionElement06"> |
| <metadata> |
| <title>HTMLOptionElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The disabled attribute indicates that this control is not available |
| within this context. |
| Retrieve the disabled attribute from the last OPTION element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-23482473"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdisabled" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="option" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"option"'/> |
| <assertSize collection="nodeList" size="10" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="9"/> |
| <disabled interface="HTMLOptionElement" obj="testNode" var="vdisabled"/> |
| <assertTrue actual="vdisabled" id="disabledLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptionElement07.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptionElement07"> |
| <metadata> |
| <title>HTMLOptionElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The label attribute is used in hierarchical menus. It specifies |
| a shorter label for an option that the content of the OPTION element. |
| Retrieve the label attribute from the second OPTION element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-40736115"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlabel" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="option" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"option"'/> |
| <assertSize collection="nodeList" size="10" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <label interface="HTMLOptionElement" obj="testNode" var="vlabel"/> |
| <assertEquals actual="vlabel" expected='"l1"' id="labelLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptionElement08.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptionElement08"> |
| <metadata> |
| <title>HTMLOptionElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The selected attribute indicates the current state of the corresponding |
| form control in an interactive user-agent. |
| Retrieve the selected attribute from the first OPTION element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-70874476"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vselected" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="option" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"option"'/> |
| <assertSize collection="nodeList" size="10" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <defaultSelected interface="HTMLOptionElement" obj="testNode" var="vselected"/> |
| <assertTrue actual="vselected" id="selectedLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLOptionElement09.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLOptionElement09"> |
| <metadata> |
| <title>HTMLOptionElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The value attribute contains the current form control value. |
| Retrieve the value attribute from the first OPTION element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6185554"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalue" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="option" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"option"'/> |
| <assertSize collection="nodeList" size="10" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <value interface="HTMLOptionElement" obj="testNode" var="vvalue"/> |
| <assertEquals actual="vvalue" expected='"10001"' id="valueLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLParagraphElement01.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLParagraphElement01"> |
| <metadata> |
| <title>HTMLParagraphElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal text alignment. |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-53465507"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="paragraph" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"p"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLParagraphElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLParamElement01.xml.kfail |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLParamElement01"> |
| <metadata> |
| <title>HTMLParamElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute specifies the name of the run-time parameter. |
| Retrieve the name attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59871447"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="param" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"param"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLParamElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"image3"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLParamElement02.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLParamElement02"> |
| <metadata> |
| <title>HTMLParamElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The value attribute specifies the value of the run-time parameter. |
| Retrieve the value attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-77971357"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalue" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="param" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"param"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <value interface="HTMLParamElement" obj="testNode" var="vvalue"/> |
| <assertURIEquals actual="vvalue" file='"file.gif"' id="valueLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLParamElement03.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLParamElement03"> |
| <metadata> |
| <title>HTMLParamElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The valueType attribute specifies information about the meaning of the |
| value specified by the value attribute. |
| Retrieve the valueType attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-23931872"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvaluetype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="param" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"param"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <valueType interface="HTMLParamElement" obj="testNode" var="vvaluetype"/> |
| <assertEquals actual="vvaluetype" expected='"ref"' id="valueTypeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLParamElement04.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLParamElement04"> |
| <metadata> |
| <title>HTMLParamElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute specifies the content type for the value attribute |
| when valuetype has the value ref. |
| Retrieve the type attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-18179888"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="param" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"param"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLParamElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"image/gif"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLPreElement01.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLPreElement01"> |
| <metadata> |
| <title>HTMLPreElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute specifies the fixed width for content. |
| Retrieve the width attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-13894083"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="pre" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"pre"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLPreElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected="277" id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLQuoteElement01.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLQuoteElement01"> |
| <metadata> |
| <title>HTMLQuoteElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The cite attribute specifies a URI designating a source document |
| or message. |
| Retrieve the cite attribute from the Q element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-53895598"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcite" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="quote" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"q"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <cite interface="HTMLQuoteElement" obj="testNode" var="vcite"/> |
| <assertURIEquals actual="vcite" file='"Q.html"' id="citeLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLQuoteElement02.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLQuoteElement02"> |
| <metadata> |
| <title>HTMLQuoteElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The cite attribute specifies a URI designating a source document |
| or message. |
| Retrieve the cite attribute from the BLOCKQUOTE element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-53895598"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcite" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="quote" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"blockquote"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <cite interface="HTMLQuoteElement" obj="testNode" var="vcite"/> |
| <assertURIEquals actual="vcite" file='"BLOCKQUOTE.html"' id="citeLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLScriptElement01.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLScriptElement01"> |
| <metadata> |
| <title>HTMLScriptElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The text attribute specifies the script content of the element. |
| Retrieve the text attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-46872999"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtext" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="script" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"script"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <text interface="HTMLScriptElement" obj="testNode" var="vtext"/> |
| <assertEquals actual="vtext" expected='"var a=2;"' id="textLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLScriptElement02.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLScriptElement02"> |
| <metadata> |
| <title>HTMLScriptElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The charset attribute specifies the character encoding of the linked |
| resource. |
| Retrieve the charset attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-35305677"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcharset" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="script" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"script"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <charset interface="HTMLScriptElement" obj="testNode" var="vcharset"/> |
| <assertEquals actual="vcharset" expected='"US-ASCII"' id="charsetLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLScriptElement03.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLScriptElement03"> |
| <metadata> |
| <title>HTMLScriptElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The defer attribute specifies the user agent can defer processing of |
| the script. |
| Retrieve the defer attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-93788534"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdefer" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="script" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"script"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <defer interface="HTMLScriptElement" obj="testNode" var="vdefer"/> |
| <assertTrue actual="vdefer" id="deferLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLScriptElement04.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLScriptElement04"> |
| <metadata> |
| <title>HTMLScriptElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The src attribute specifies a URI designating an external script. |
| Retrieve the src attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-75147231"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsrc" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="script" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"script"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <src interface="HTMLScriptElement" obj="testNode" var="vsrc"/> |
| <assertURIEquals actual="vsrc" file='"script1.js"' id="srcLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLScriptElement05.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLScriptElement05"> |
| <metadata> |
| <title>HTMLScriptElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute specifies the content of the script language. |
| Retrieve the type attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-30534818"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="script" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"script"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLScriptElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"text/javaScript"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLScriptElement06.xml.kfail |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLScriptElement06"> |
| <metadata> |
| <title>HTMLScriptElement06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| htmlFor is described as for future use. Test accesses the value, but makes no assertions about its value. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-66979266"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="htmlFor" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="script" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"script"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <htmlFor interface="HTMLScriptElement" obj="testNode" var="htmlFor"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLScriptElement07.xml.kfail |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLScriptElement07"> |
| <metadata> |
| <title>HTMLScriptElement07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| event is described as for future use. Test accesses the value, but makes no assertions about its value. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-56700403"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="event" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="script" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"script"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <event interface="HTMLScriptElement" obj="testNode" var="event"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement01.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement01"> |
| <metadata> |
| <title>HTMLSelectElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute is the string "select-multiple" when multiple |
| attribute is true. |
| Retrieve the type attribute from the first SELECT element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-58783172"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLSelectElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"select-multiple"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement02.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement02"> |
| <metadata> |
| <title>HTMLSelectElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The selectedIndex attribute specifies the ordinal index of the selected |
| option. |
| Retrieve the selectedIndex attribute from the first SELECT element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-85676760"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vselectedindex" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <selectedIndex interface="HTMLSelectElement" obj="testNode" var="vselectedindex"/> |
| <assertEquals actual="vselectedindex" expected="0" id="selectedIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement03.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement03"> |
| <metadata> |
| <title>HTMLSelectElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The selectedIndex attribute specifies the ordinal index of the selected |
| option. If no element is selected -1 is returned. |
| Retrieve the selectedIndex attribute from the second SELECT element and |
| examine its value. |
| Per http://www.w3.org/TR/html401/interact/forms.html#h-17.6.1, |
| without an explicit selected attribute, user agent behavior is |
| undefined. There is no way to coerce no option to be selected. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-85676760"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vselectedindex" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <selectedIndex interface="HTMLSelectElement" obj="testNode" var="vselectedindex"/> |
| <!-- Commented assertion per section 17.6.3 --> |
| <!-- assertEquals actual="vselectedindex" expected="-1" id="selectedIndexLink" ignoreCase="false"/ --> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement04.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement04"> |
| <metadata> |
| <title>HTMLSelectElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The value attribute specifies the current form control value. |
| Retrieve the value attribute from the first SELECT element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59351919"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalue" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <value interface="HTMLSelectElement" obj="testNode" var="vvalue"/> |
| <assertEquals actual="vvalue" expected='"EMP1"' id="valueLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement05.xml.int-broken |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement05"> |
| <metadata> |
| <title>HTMLSelectElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The length attribute specifies the number of options in this select. |
| Retrieve the length attribute from the first SELECT element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-5933486"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vlength" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <length interface="HTMLSelectElement" obj="testNode" var="vlength"/> |
| <assertEquals actual="vlength" expected="5" id="lengthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement06.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement06"> |
| <metadata> |
| <title>HTMLSelectElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns the FORM element containing this control. |
| Retrieve the form attribute from the first SELECT element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-20489458"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="DOMString" /> |
| <var name="fNode" type="HTMLFormElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLSelectElement" obj="testNode" var="fNode"/> |
| <id obj="fNode" var="vform"/> |
| <assertEquals actual="vform" expected='"form1"' id="formLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement07.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement07"> |
| <metadata> |
| <title>HTMLSelectElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns null if control in not within the context of |
| a form. |
| Retrieve the second SELECT element and |
| examine its form element. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-20489458"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="HTMLFormElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <form interface="HTMLSelectElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formNullLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement08.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement08"> |
| <metadata> |
| <title>HTMLSelectElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The options attribute returns a collection of OPTION elements contained |
| by this element. |
| Retrieve the options attribute from the first SELECT element and |
| examine the items of the returned collection. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-30606413"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="optionsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="vareas" type="int" /> |
| <var name="doc" type="Document"/> |
| <var name="optionName" type="DOMString"/> |
| <var name="voption" type="Node"/> |
| <var name="result" type="List"/> |
| <var name="expectedOptions" type="List"> |
| <member>"option"</member> |
| <member>"option"</member> |
| <member>"option"</member> |
| <member>"option"</member> |
| <member>"option"</member> |
| </var> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <options interface="HTMLSelectElement" obj="testNode" var="optionsnodeList"/> |
| <for-each collection="optionsnodeList" member="voption"> |
| <nodeName obj="voption" var="optionName"/> |
| <append collection="result" item="optionName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedOptions" id="optionsLink" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement09.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement09"> |
| <metadata> |
| <title>HTMLSelectElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The disabled attribute indicates that this control is not available |
| within this context. |
| Retrieve the disabled attribute from the third SELECT element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-79102918"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdisabled" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="2"/> |
| <disabled interface="HTMLSelectElement" obj="testNode" var="vdisabled"/> |
| <assertTrue actual="vdisabled" id="disabledLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement10.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement10"> |
| <metadata> |
| <title>HTMLSelectElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The multiple attribute(if true) indicates that multiple OPTION elements |
| may be selected |
| Retrieve the multiple attribute from the first SELECT element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-13246613"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vmultiple" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <multiple interface="HTMLSelectElement" obj="testNode" var="vmultiple"/> |
| <assertTrue actual="vmultiple" id="multipleLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement11.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement11"> |
| <metadata> |
| <title>HTMLSelectElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute specifies the form control or object name when |
| submitted with a form. |
| Retrieve the name attribute from the first SELECT element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-41636323"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLSelectElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"select1"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement12.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement12"> |
| <metadata> |
| <title>HTMLSelectElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The size attribute specifies the number of visible rows. |
| Retrieve the size attribute from the first SELECT element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-18293826"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsize" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <size interface="HTMLSelectElement" obj="testNode" var="vsize"/> |
| <assertEquals actual="vsize" expected="1" id="sizeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement13.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement13"> |
| <metadata> |
| <title>HTMLSelectElement13</title> |
| <creator>NIST</creator> |
| <description> |
| The tabIndex attribute specifies an index that represents the elements |
| position in the tabbing order. |
| Retrieve the tabIndex attribute from the first SELECT element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-40676705"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtabindex" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tabIndex interface="HTMLSelectElement" obj="testNode" var="vtabindex"/> |
| <assertEquals actual="vtabindex" expected="7" id="tabIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement14.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement14"> |
| <metadata> |
| <title>HTMLSelectElement14</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| focus should give the select element input focus. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-32130014"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <focus interface="HTMLSelectElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement15.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement15"> |
| <metadata> |
| <title>HTMLSelectElement15</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| blur should surrender input focus. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-28216144"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="select" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <blur interface="HTMLSelectElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement16.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement16"> |
| <metadata> |
| <title>HTMLSelectElement16</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Removes an option using HTMLSelectElement.remove. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-33404570"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <var name="optLength" type="int"/> |
| <var name="selected" type="int"/> |
| <load var="doc" href="select" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <remove interface="HTMLSelectElement" obj="testNode" index="0"/> |
| <length interface="HTMLSelectElement" obj="testNode" var="optLength"/> |
| <assertEquals actual="optLength" expected="4" id="optLength" ignoreCase="false"/> |
| <selectedIndex interface="HTMLSelectElement" obj="testNode" var="selected"/> |
| <assertEquals actual="selected" expected="-1" id="selected" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement17.xml.int-broken |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement17"> |
| <metadata> |
| <title>HTMLSelectElement17</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Removes a non-existant option using HTMLSelectElement.remove. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-33404570"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <var name="optLength" type="int"/> |
| <var name="selected" type="int"/> |
| <load var="doc" href="select" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <remove interface="HTMLSelectElement" obj="testNode" index="6"/> |
| <length interface="HTMLSelectElement" obj="testNode" var="optLength"/> |
| <assertEquals actual="optLength" expected="5" id="optLength" ignoreCase="false"/> |
| <selectedIndex interface="HTMLSelectElement" obj="testNode" var="selected"/> |
| <assertEquals actual="selected" expected="0" id="selected" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement18.xml.kfail |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement18"> |
| <metadata> |
| <title>HTMLSelectElement18</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add a new option at the end of an select using HTMLSelectElement.add. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-14493106"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <var name="optLength" type="int"/> |
| <var name="selected" type="int"/> |
| <var name="newOpt" type="Element"/> |
| <var name="newOptText" type="Text"/> |
| <var name="opt" type="Element"/> |
| <var name="optText" type="Text"/> |
| <var name="optValue" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <var name="nullNode" type="Node" isNull="true"/> |
| <load var="doc" href="select" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <createElement var="newOpt" obj="doc" tagName='"option"'/> |
| <createTextNode var="newOptText" obj="doc" data='"EMP31415"'/> |
| <appendChild var="retNode" obj="newOpt" newChild="newOptText"/> |
| <add interface="HTMLSelectElement" obj="testNode" element="newOpt" before="nullNode"/> |
| <length interface="HTMLSelectElement" obj="testNode" var="optLength"/> |
| <assertEquals actual="optLength" expected="6" id="optLength" ignoreCase="false"/> |
| <selectedIndex interface="HTMLSelectElement" obj="testNode" var="selected"/> |
| <assertEquals actual="selected" expected="0" id="selected" ignoreCase="false"/> |
| <lastChild var="opt" obj="testNode" interface="Node"/> |
| <firstChild var="optText" obj="opt" interface="Node"/> |
| <nodeValue var="optValue" obj="optText"/> |
| <assertEquals actual="optValue" expected='"EMP31415"' id="lastValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLSelectElement19.xml.kfail |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLSelectElement19"> |
| <metadata> |
| <title>HTMLSelectElement19</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add a new option before the selected node using HTMLSelectElement.add. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-14493106"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <var name="optLength" type="int"/> |
| <var name="selected" type="int"/> |
| <var name="newOpt" type="Element"/> |
| <var name="newOptText" type="Text"/> |
| <var name="opt" type="Element"/> |
| <var name="optText" type="Text"/> |
| <var name="optValue" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <var name="options" type="HTMLCollection"/> |
| <var name="selectedNode" type="Node"/> |
| <load var="doc" href="select" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <createElement var="newOpt" obj="doc" tagName='"option"'/> |
| <createTextNode var="newOptText" obj="doc" data='"EMP31415"'/> |
| <appendChild var="retNode" obj="newOpt" newChild="newOptText"/> |
| <options var="options" obj="testNode"/> |
| <item var="selectedNode" obj="options" index="0" interface="HTMLCollection"/> |
| <add interface="HTMLSelectElement" obj="testNode" element="newOpt" before="selectedNode"/> |
| <length interface="HTMLSelectElement" obj="testNode" var="optLength"/> |
| <assertEquals actual="optLength" expected="6" id="optLength" ignoreCase="false"/> |
| <selectedIndex interface="HTMLSelectElement" obj="testNode" var="selected"/> |
| <assertEquals actual="selected" expected="1" id="selected" ignoreCase="false"/> |
| <options var="options" obj="testNode"/> |
| <item var="opt" obj="options" index="0" interface="HTMLCollection"/> |
| <firstChild var="optText" obj="opt" interface="Node"/> |
| <nodeValue var="optValue" obj="optText"/> |
| <assertEquals actual="optValue" expected='"EMP31415"' id="lastValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLStyleElement01.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLStyleElement01"> |
| <metadata> |
| <title>HTMLStyleElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The disabled attribute enables/disables the stylesheet. |
| Retrieve the disabled attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-51162010"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdisabled" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="style" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"style"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <disabled interface="HTMLStyleElement" obj="testNode" var="vdisabled"/> |
| <assertFalse actual="vdisabled" id="disabledLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLStyleElement02.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLStyleElement02"> |
| <metadata> |
| <title>HTMLStyleElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The media attribute identifies the intended medium of the style info. |
| Retrieve the media attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-76412738"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vmedia" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="style" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"style"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <media interface="HTMLStyleElement" obj="testNode" var="vmedia"/> |
| <assertEquals actual="vmedia" expected='"screen"' id="mediaLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLStyleElement03.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLStyleElement03"> |
| <metadata> |
| <title>HTMLStyleElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute specifies the style sheet language(Internet media type). |
| Retrieve the type attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-22472002"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="style" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"style"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLStyleElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"text/css"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCaptionElement01.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCaptionElement01"> |
| <metadata> |
| <title>HTMLTableCaptionElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the caption alignment with respect to |
| the table. |
| Retrieve the align attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-79875068"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecaption" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"caption"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLTableCaptionElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"top"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement01.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement01"> |
| <metadata> |
| <title>HTMLTableCellElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The cellIndex attribute specifies the index of this cell in the row(TH). |
| Retrieve the cellIndex attribute of the first TH element and examine its |
| value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-80748363"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcellindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <cellIndex interface="HTMLTableCellElement" obj="testNode" var="vcellindex"/> |
| <assertEquals actual="vcellindex" expected="0" id="cellIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement02.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement02"> |
| <metadata> |
| <title>HTMLTableCellElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The cellIndex attribute specifies the index of this cell in the row(TD). |
| Retrieve the cellIndex attribute of the first TD element and examine its |
| value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-80748363"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcellindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <cellIndex interface="HTMLTableCellElement" obj="testNode" var="vcellindex"/> |
| <assertEquals actual="vcellindex" expected="0" id="cellIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement03.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement03"> |
| <metadata> |
| <title>HTMLTableCellElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The abbr attribute specifies the abbreviation for table header cells(TH). |
| Retrieve the abbr attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-74444037"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vabbr" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <abbr interface="HTMLTableCellElement" obj="testNode" var="vabbr"/> |
| <assertEquals actual="vabbr" expected='"hd1"' id="abbrLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement04.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement04"> |
| <metadata> |
| <title>HTMLTableCellElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The abbr attribute specifies the abbreviation for table data cells(TD). |
| Retrieve the abbr attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-74444037"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vabbr" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <abbr interface="HTMLTableCellElement" obj="testNode" var="vabbr"/> |
| <assertEquals actual="vabbr" expected='"hd2"' id="abbrLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement05.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement05"> |
| <metadata> |
| <title>HTMLTableCellElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal alignment for table |
| header cells(TH). |
| Retrieve the align attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-98433879"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <align interface="HTMLTableCellElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement06.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement06"> |
| <metadata> |
| <title>HTMLTableCellElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal alignment for table |
| data cells(TD). |
| Retrieve the align attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-98433879"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <align interface="HTMLTableCellElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement07.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement07"> |
| <metadata> |
| <title>HTMLTableCellElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The axis attribute specifies the names group of related headers for table |
| header cells(TH). |
| Retrieve the align attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-76554418"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaxis" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <axis interface="HTMLTableCellElement" obj="testNode" var="vaxis"/> |
| <assertEquals actual="vaxis" expected='"center"' id="axisLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement08.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement08"> |
| <metadata> |
| <title>HTMLTableCellElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The axis attribute specifies the names group of related headers for table |
| data cells(TD). |
| Retrieve the axis attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-76554418"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaxis" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <axis interface="HTMLTableCellElement" obj="testNode" var="vaxis"/> |
| <assertEquals actual="vaxis" expected='"center"' id="axisLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement09.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement09"> |
| <metadata> |
| <title>HTMLTableCellElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The bgColor attribute specifies the cells background color for |
| table header cells(TH). |
| Retrieve the bgColor attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88135431"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vbgcolor" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <bgColor interface="HTMLTableCellElement" obj="testNode" var="vbgcolor"/> |
| <assertEquals actual="vbgcolor" expected='"#00FFFF"' id="bgColorLink" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement10.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement10"> |
| <metadata> |
| <title>HTMLTableCellElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The bgColor attribute specifies the cells background color for table |
| data cells(TD). |
| Retrieve the bgColor attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88135431"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vbgcolor" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <bgColor interface="HTMLTableCellElement" obj="testNode" var="vbgcolor"/> |
| <assertEquals actual="vbgcolor" expected='"#FF0000"' id="bgColorLink" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement11.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement11"> |
| <metadata> |
| <title>HTMLTableCellElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The char attribute specifies the alignment character for cells in a column |
| of table header cells(TH). |
| Retrieve the char attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-30914780"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <ch interface="HTMLTableCellElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='":"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement12.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement12"> |
| <metadata> |
| <title>HTMLTableCellElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The char attribute specifies the alignment character for cells in a column |
| of table data cells(TD). |
| Retrieve the char attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-30914780"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <ch interface="HTMLTableCellElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='":"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement13.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement13"> |
| <metadata> |
| <title>HTMLTableCellElement13</title> |
| <creator>NIST</creator> |
| <description> |
| The charoff attribute specifies the offset of alignment characacter |
| of table header cells(TH). |
| Retrieve the charoff attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-20144310"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcharoff" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <chOff interface="HTMLTableCellElement" obj="testNode" var="vcharoff"/> |
| <assertEquals actual="vcharoff" expected='"1"' id="chOffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement14.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement14"> |
| <metadata> |
| <title>HTMLTableCellElement14</title> |
| <creator>NIST</creator> |
| <description> |
| The charoff attribute specifies the offset of alignment character |
| of table data cells(TD). |
| Retrieve the charoff attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-20144310"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcharoff" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <chOff interface="HTMLTableCellElement" obj="testNode" var="vcharoff"/> |
| <assertEquals actual="vcharoff" expected='"1"' id="chOffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement15.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement15"> |
| <metadata> |
| <title>HTMLTableCellElement15</title> |
| <creator>NIST</creator> |
| <description> |
| The colSpan attribute specifies the number of columns spanned by a table |
| header(TH) cell. |
| Retrieve the colspan attribute of the second TH element and examine its |
| value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-84645244"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcolspan" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <colSpan interface="HTMLTableCellElement" obj="testNode" var="vcolspan"/> |
| <assertEquals actual="vcolspan" expected="1" id="colSpanLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement16.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement16"> |
| <metadata> |
| <title>HTMLTableCellElement16</title> |
| <creator>NIST</creator> |
| <description> |
| The colSpan attribute specifies the number of columns spanned by a |
| table data(TD) cell. |
| Retrieve the colSpan attribute of the second TD element and examine its |
| value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-84645244"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcolspan" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <colSpan interface="HTMLTableCellElement" obj="testNode" var="vcolspan"/> |
| <assertEquals actual="vcolspan" expected="1" id="colSpanLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement17.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement17"> |
| <metadata> |
| <title>HTMLTableCellElement17</title> |
| <creator>NIST</creator> |
| <description> |
| The headers attribute specifies a list of id attribute values for |
| table header cells(TH). |
| Retrieve the headers attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-89104817"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheaders" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <headers interface="HTMLTableCellElement" obj="testNode" var="vheaders"/> |
| <assertEquals actual="vheaders" expected='"header-1"' id="headersLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement18.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement18"> |
| <metadata> |
| <title>HTMLTableCellElement18</title> |
| <creator>NIST</creator> |
| <description> |
| The headers attribute specifies a list of id attribute values for |
| table data cells(TD). |
| Retrieve the headers attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-89104817"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheaders" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <headers interface="HTMLTableCellElement" obj="testNode" var="vheaders"/> |
| <assertEquals actual="vheaders" expected='"header-3"' id="headersLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement19.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement19"> |
| <metadata> |
| <title>HTMLTableCellElement19</title> |
| <creator>NIST</creator> |
| <description> |
| The height attribute specifies the cell height. |
| Retrieve the height attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83679212"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheight" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <height interface="HTMLTableCellElement" obj="testNode" var="vheight"/> |
| <assertEquals actual="vheight" expected='"50"' id="heightLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement20.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement20"> |
| <metadata> |
| <title>HTMLTableCellElement20</title> |
| <creator>NIST</creator> |
| <description> |
| The height attribute specifies the cell height. |
| Retrieve the height attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83679212"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheight" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <height interface="HTMLTableCellElement" obj="testNode" var="vheight"/> |
| <assertEquals actual="vheight" expected='"50"' id="heightLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement21.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement21"> |
| <metadata> |
| <title>HTMLTableCellElement21</title> |
| <creator>NIST</creator> |
| <description> |
| The noWrap attribute supresses word wrapping. |
| Retrieve the noWrap attribute of the second TH Element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-62922045"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vnowrap" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <noWrap interface="HTMLTableCellElement" obj="testNode" var="vnowrap"/> |
| <assertTrue actual="vnowrap" id="noWrapLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement22.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement22"> |
| <metadata> |
| <title>HTMLTableCellElement22</title> |
| <creator>NIST</creator> |
| <description> |
| The noWrap attribute supresses word wrapping. |
| Retrieve the noWrap attribute of the second TD Element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-62922045"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vnowrap" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <noWrap interface="HTMLTableCellElement" obj="testNode" var="vnowrap"/> |
| <assertTrue actual="vnowrap" id="noWrapLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement23.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement23"> |
| <metadata> |
| <title>HTMLTableCellElement23</title> |
| <creator>NIST</creator> |
| <description> |
| The rowSpan attribute specifies the number of rows spanned by a table |
| header(TH) cell. |
| Retrieve the rowSpan attribute of the second TH element and examine its |
| value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-48237625"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrowspan" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rowSpan interface="HTMLTableCellElement" obj="testNode" var="vrowspan"/> |
| <assertEquals actual="vrowspan" expected="1" id="rowSpanLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement24.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement24"> |
| <metadata> |
| <title>HTMLTableCellElement24</title> |
| <creator>NIST</creator> |
| <description> |
| The rowSpan attribute specifies the number of rows spanned by a |
| table data(TD) cell. |
| Retrieve the rowSpan attribute of the second TD element and examine its |
| value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-48237625"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrowspan" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rowSpan interface="HTMLTableCellElement" obj="testNode" var="vrowspan"/> |
| <assertEquals actual="vrowspan" expected="1" id="rowSpanLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement25.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement25"> |
| <metadata> |
| <title>HTMLTableCellElement25</title> |
| <creator>NIST</creator> |
| <description> |
| The scope attribute specifies the scope covered by header cells. |
| Retrieve the scope attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-36139952"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vscope" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <scope interface="HTMLTableCellElement" obj="testNode" var="vscope"/> |
| <assertEquals actual="vscope" expected='"col"' id="scopeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement26.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement26"> |
| <metadata> |
| <title>HTMLTableCellElement26</title> |
| <creator>NIST</creator> |
| <description> |
| The scope attribute specifies the scope covered by data cells. |
| Retrieve the scope attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-36139952"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vscope" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <scope interface="HTMLTableCellElement" obj="testNode" var="vscope"/> |
| <assertEquals actual="vscope" expected='"col"' id="scopeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement27.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement27"> |
| <metadata> |
| <title>HTMLTableCellElement27</title> |
| <creator>NIST</creator> |
| <description> |
| The vAlign attribute specifies the vertical alignment of data in cell. |
| Retrieve the vAlign attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-58284221"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <vAlign interface="HTMLTableCellElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement28.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement28"> |
| <metadata> |
| <title>HTMLTableCellElement28</title> |
| <creator>NIST</creator> |
| <description> |
| The vAlign attribute specifies the vertical alignment of data in cell. |
| Retrieve the vAlign attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-58284221"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <vAlign interface="HTMLTableCellElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement29.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement29"> |
| <metadata> |
| <title>HTMLTableCellElement29</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute specifies the cells width. |
| Retrieve the width attribute from the second TH element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-27480795"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"th"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <width interface="HTMLTableCellElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"170"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableCellElement30.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableCellElement30"> |
| <metadata> |
| <title>HTMLTableCellElement30</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute specifies the cells width. |
| Retrieve the width attribute from the second TD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-27480795"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <width interface="HTMLTableCellElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"175"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement01.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement01"> |
| <metadata> |
| <title>HTMLTableColElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal alignment of cell data |
| in column(COL). |
| Retrieve the align attribute from the COL element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-31128447"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLTableColElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement02.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement02"> |
| <metadata> |
| <title>HTMLTableColElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal alignment of cell data |
| in column(COLGROUP). |
| Retrieve the align attribute from the COLGROUP element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-31128447"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"colgroup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLTableColElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement03.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement03"> |
| <metadata> |
| <title>HTMLTableColElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The char attribute specifies the alignment character for cells |
| in a column(COL). |
| Retrieve the char attribute from the COL element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-9447412"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <ch interface="HTMLTableColElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='"*"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement04.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement04"> |
| <metadata> |
| <title>HTMLTableColElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The char attribute specifies the alignment character for cells |
| in a column(COLGROUP). |
| Retrieve the char attribute from the COLGROUP element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-9447412"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"colgroup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <ch interface="HTMLTableColElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='"$"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement05.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement05"> |
| <metadata> |
| <title>HTMLTableColElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The charoff attribute specifies offset of alignment character(COL). |
| Retrieve the charoff attribute from the COL element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-57779225"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vchoff" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <chOff interface="HTMLTableColElement" obj="testNode" var="vchoff"/> |
| <assertEquals actual="vchoff" expected='"20"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement06.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement06"> |
| <metadata> |
| <title>HTMLTableColElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The charoff attribute specifies offset of alignment character(COLGROUP). |
| Retrieve the charoff attribute from the COLGROUP element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-57779225"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vchoff" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"colgroup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <chOff interface="HTMLTableColElement" obj="testNode" var="vchoff"/> |
| <assertEquals actual="vchoff" expected='"15"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement07.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement07"> |
| <metadata> |
| <title>HTMLTableColElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The span attribute indicates the number of columns in a group or affected |
| by a grouping(COL). |
| Retrieve the span attribute of the COL element and examine its |
| value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-96511335"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vspan" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <span interface="HTMLTableColElement" obj="testNode" var="vspan"/> |
| <assertEquals actual="vspan" expected="1" id="spanLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement08.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement08"> |
| <metadata> |
| <title>HTMLTableColElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The span attribute indicates the number of columns in a group or affected |
| by a grouping(COLGROUP). |
| Retrieve the span attribute of the COLGROUP element and examine its |
| value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-96511335"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vspan" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"colgroup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <span interface="HTMLTableColElement" obj="testNode" var="vspan"/> |
| <assertEquals actual="vspan" expected="2" id="spanLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement09.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement09"> |
| <metadata> |
| <title>HTMLTableColElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The vAlign attribute specifies the vertical alignment of cell data |
| in column(COL). |
| Retrieve the vAlign attribute from the COL element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83291710"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vAlign interface="HTMLTableColElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement10.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement10"> |
| <metadata> |
| <title>HTMLTableColElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The vAlign attribute specifies the vertical alignment of cell data |
| in column(COLGROUP). |
| Retrieve the vAlign attribute from the COLGROUP element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83291710"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"colgroup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vAlign interface="HTMLTableColElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement11.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement11"> |
| <metadata> |
| <title>HTMLTableColElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute specifies the default column width(COL). |
| Retrieve the width attribute from the COL element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-25196799"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLTableColElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"20"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableColElement12.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableColElement12"> |
| <metadata> |
| <title>HTMLTableColElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute specifies the default column width(COLGORUP). |
| Retrieve the width attribute from the COLGROUP element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-25196799"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"colgroup"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLTableColElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"20"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement01.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement01"> |
| <metadata> |
| <title>HTMLTableElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The caption attribute returns the tables CAPTION. |
| Retrieve the align attribute of the CAPTION element from the second |
| TABLE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-14594520"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcaption" type="HTMLTableCaptionElement" /> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <caption interface="HTMLTableElement" obj="testNode" var="vcaption"/> |
| <align interface="HTMLTableCaptionElement" obj="vcaption" var="valign"/> |
| <assertEquals actual="valign" expected='"top"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement02.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement02"> |
| <metadata> |
| <title>HTMLTableElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The caption attribute returns the tables CAPTION or void if it does not |
| exist. |
| Retrieve the CAPTION element from within the first TABLE element. |
| Since one does not exist it should be void. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-14594520"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcaption" type="HTMLTableCaptionElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <caption interface="HTMLTableElement" obj="testNode" var="vcaption"/> |
| <assertNull actual="vcaption" id="captionLink" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement03.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement03"> |
| <metadata> |
| <title>HTMLTableElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The tHead attribute returns the tables THEAD. |
| Retrieve the align attribute of the THEAD element from the second |
| TABLE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-9530944"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <align interface="HTMLTableSectionElement" obj="vsection" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement04.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement04"> |
| <metadata> |
| <title>HTMLTableElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The tHead attribute returns the tables THEAD or null if it does not |
| exist. |
| Retrieve the THEAD element from within the first TABLE element. |
| Since one does not exist it should be null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-9530944"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <assertNull actual="vsection" id="sectionLink" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement05.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement05"> |
| <metadata> |
| <title>HTMLTableElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The tFoot attribute returns the tables TFOOT. |
| Retrieve the align attribute of the TFOOT element from the second |
| TABLE element and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64197097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <align interface="HTMLTableSectionElement" obj="vsection" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement06.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement06"> |
| <metadata> |
| <title>HTMLTableElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The tFoot attribute returns the tables TFOOT or null if it does not |
| exist. |
| Retrieve the TFOOT element from within the first TABLE element. |
| Since one does not exist it should be null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64197097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <assertNull actual="vsection" id="sectionLink" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement07.xml.kfail |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement07"> |
| <metadata> |
| <title>HTMLTableElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The rows attribute returns a collection of all the rows in the table, |
| including al in THEAD, TFOOT, all TBODY elements. |
| Retrieve the rows attribute from the second TABLE element and |
| examine the items of the returned collection. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6156016"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <var name="rowName" type="DOMString"/> |
| <var name="vrow" type="Node"/> |
| <var name="result" type="List"/> |
| <var name="expectedOptions" type="List"> |
| <member>"tr"</member> |
| <member>"tr"</member> |
| <member>"tr"</member> |
| <member>"tr"</member> |
| </var> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <for-each collection="rowsnodeList" member="vrow"> |
| <nodeName obj="vrow" var="rowName"/> |
| <append collection="result" item="rowName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedOptions" id="rowsLink" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement08.xml.kfail |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement08"> |
| <metadata> |
| <title>HTMLTableElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The tBodies attribute returns a collection of all the defined |
| table bodies. |
| Retrieve the tBodies attribute from the second TABLE element and |
| examine the items of the returned collection. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63206416"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="tbodiesnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <var name="tbodiesName" type="DOMString"/> |
| <var name="vtbodies" type="Node"/> |
| <var name="result" type="List"/> |
| <var name="expectedOptions" type="List"> |
| <member>"tbody"</member> |
| </var> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tBodies interface="HTMLTableElement" obj="testNode" var="tbodiesnodeList"/> |
| <for-each collection="tbodiesnodeList" member="vtbodies"> |
| <nodeName obj="vtbodies" var="tbodiesName"/> |
| <append collection="result" item="tbodiesName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedOptions" id="tbodiesLink" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement09.xml.kfail |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement09"> |
| <metadata> |
| <title>HTMLTableElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The tBodies attribute returns a collection of all the defined |
| table bodies. |
| Retrieve the tBodies attribute from the third TABLE element and |
| examine the items of the returned collection. Tests multiple TBODY |
| elements. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63206416"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="tbodiesnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <var name="tbodiesName" type="DOMString"/> |
| <var name="vtbodies" type="Node"/> |
| <var name="result" type="List"/> |
| <var name="expectedOptions" type="List"> |
| <member>"tbody"</member> |
| <member>"tbody"</member> |
| <member>"tbody"</member> |
| </var> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="2"/> |
| <tBodies interface="HTMLTableElement" obj="testNode" var="tbodiesnodeList"/> |
| <for-each collection="tbodiesnodeList" member="vtbodies"> |
| <nodeName obj="vtbodies" var="tbodiesName"/> |
| <append collection="result" item="tbodiesName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedOptions" id="tbodiesLink" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement10.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement10"> |
| <metadata> |
| <title>HTMLTableElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the table's position with respect to the |
| rest of the document. |
| Retrieve the align attribute of the first TABLE element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-23180977"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLTableElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement11.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement11"> |
| <metadata> |
| <title>HTMLTableElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The bgColor attribute specifies cell background color. |
| Retrieve the bgColor attribute of the first TABLE element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83532985"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vbgcolor" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <bgColor interface="HTMLTableElement" obj="testNode" var="vbgcolor"/> |
| <assertEquals actual="vbgcolor" expected='"#ff0000"' id="bgColorLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement12.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement12"> |
| <metadata> |
| <title>HTMLTableElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The border attribute specifies the width of the border around the table. |
| Retrieve the border attribute of the first TABLE element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-50969400"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vborder" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <border interface="HTMLTableElement" obj="testNode" var="vborder"/> |
| <assertEquals actual="vborder" expected='"4"' id="borderLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement13.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement13"> |
| <metadata> |
| <title>HTMLTableElement13</title> |
| <creator>NIST</creator> |
| <description> |
| The cellpadding attribute specifies the horizontal and vertical space |
| between cell content and cell borders. |
| Retrieve the cellpadding attribute of the first TABLE element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59162158"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcellpadding" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <cellPadding interface="HTMLTableElement" obj="testNode" var="vcellpadding"/> |
| <assertEquals actual="vcellpadding" expected='"2"' id="cellPaddingLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement14.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement14"> |
| <metadata> |
| <title>HTMLTableElement14</title> |
| <creator>NIST</creator> |
| <description> |
| The cellSpacing attribute specifies the horizontal and vertical separation |
| between cells. |
| Retrieve the cellSpacing attribute of the first TABLE element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-68907883"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="cellSpacing" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <cellSpacing interface="HTMLTableElement" obj="testNode" var="cellSpacing"/> |
| <assertEquals actual="cellSpacing" expected='"2"' id="cellSpacingLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement15.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement15"> |
| <metadata> |
| <title>HTMLTableElement15</title> |
| <creator>NIST</creator> |
| <description> |
| The frame attribute specifies which external table borders to render. |
| Retrieve the frame attribute of the first TABLE element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64808476"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vframe" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <frame interface="HTMLTableElement" obj="testNode" var="vframe"/> |
| <assertEquals actual="vframe" expected='"border"' id="frameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement16.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement16"> |
| <metadata> |
| <title>HTMLTableElement16</title> |
| <creator>NIST</creator> |
| <description> |
| The rules attribute specifies which internal table borders to render. |
| Retrieve the rules attribute of the first TABLE element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-26347553"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrules" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rules interface="HTMLTableElement" obj="testNode" var="vrules"/> |
| <assertEquals actual="vrules" expected='"all"' id="rulesLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement17.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement17"> |
| <metadata> |
| <title>HTMLTableElement17</title> |
| <creator>NIST</creator> |
| <description> |
| The summary attribute is a description about the purpose or structure |
| of a table. |
| Retrieve the summary attribute of the first TABLE element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-44998528"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsummary" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <summary interface="HTMLTableElement" obj="testNode" var="vsummary"/> |
| <assertEquals actual="vsummary" expected='"HTML Control Table"' id="summaryLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement18.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement18"> |
| <metadata> |
| <title>HTMLTableElement18</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute specifies the desired table width. |
| Retrieve the width attribute of the first TABLE element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-77447361"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <width interface="HTMLTableElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"680"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement19.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement19"> |
| <metadata> |
| <title>HTMLTableElement19</title> |
| <creator>NIST</creator> |
| <description> |
| The createTHead() method creates a table header row or returns |
| an existing one. |
| Create a new THEAD element on the first TABLE element. The first |
| TABLE element should return null to make sure one doesn't exist. |
| After creation of the THEAD element the value is once again |
| checked and should not be null. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-70313345"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection1" type="HTMLTableSectionElement" /> |
| <var name="vsection2" type="HTMLTableSectionElement" /> |
| <var name="newHead" type="HTMLElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection1"/> |
| <assertNull actual="vsection1" id="vsection1Id"/> |
| <createTHead interface="HTMLTableElement" obj="testNode" var="newHead"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection2"/> |
| <assertNotNull actual="vsection2" id="vsection2Id"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement20.xml.kfail |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement20"> |
| <metadata> |
| <title>HTMLTableElement20</title> |
| <creator>NIST</creator> |
| <description> |
| The createTHead() method creates a table header row or returns |
| an existing one. |
| Try to create a new THEAD element on the second TABLE element. |
| Since a THEAD element already exists in the TABLE element a new |
| THEAD element is not created and information from the already |
| existing THEAD element is returned. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-70313345"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="newHead" type="HTMLElement" /> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <createTHead interface="HTMLTableElement" obj="testNode" var="newHead"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <align interface="HTMLTableSectionElement" obj="vsection" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement21.xml.kfail |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement21"> |
| <metadata> |
| <title>HTMLTableElement21</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteTHead() method deletes the header from the table. |
| The deleteTHead() method will delete the THEAD Element from the |
| second TABLE element. First make sure that the THEAD element exists |
| and then count the number of rows. After the THEAD element is |
| deleted there should be one less row. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-38310198"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection1" type="HTMLTableElement" /> |
| <var name="vsection2" type="HTMLTableElement" /> |
| <var name="vrows" type="int"/> |
| <var name="doc" type="Document"/> |
| <var name="result" type="List"/> |
| <var name="expectedResult" type="List"> |
| <member>4</member> |
| <member>3</member> |
| </var> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection1"/> |
| <assertNotNull actual="vsection1" id="vsection1Id"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <append collection="result" item="vrows"/> |
| <deleteTHead obj="testNode" interface="HTMLTableElement"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection2"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <append collection="result" item="vrows"/> |
| <assertEquals actual="result" expected="expectedResult" id="rowsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement22.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement22"> |
| <metadata> |
| <title>HTMLTableElement22</title> |
| <creator>NIST</creator> |
| <description> |
| The createTFoot() method creates a table footer row or returns |
| an existing one. |
| Create a new TFOOT element on the first TABLE element. The first |
| TABLE element should return null to make sure one doesn't exist. |
| After creation of the TFOOT element the value is once again |
| checked and should not be null. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-8453710"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection1" type="HTMLTableSectionElement" /> |
| <var name="vsection2" type="HTMLTableSectionElement" /> |
| <var name="newFoot" type="HTMLElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection1"/> |
| <assertNull actual="vsection1" id="vsection1Id"/> |
| <createTFoot interface="HTMLTableElement" obj="testNode" var="newFoot"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection2"/> |
| <assertNotNull actual="vsection2" id="vsection2Id"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement23.xml.kfail |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement23"> |
| <metadata> |
| <title>HTMLTableElement23</title> |
| <creator>NIST</creator> |
| <description> |
| The createTFoot() method creates a table footer row or returns |
| an existing one. |
| Try to create a new TFOOT element on the second TABLE element. |
| Since a TFOOT element already exists in the TABLE element a new |
| TFOOT element is not created and information from the already |
| existing TFOOT element is returned. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-8453710"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="newFoot" type="HTMLElement" /> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <createTFoot interface="HTMLTableElement" obj="testNode" var="newFoot"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <align interface="HTMLTableSectionElement" obj="vsection" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement24.xml.kfail |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement24"> |
| <metadata> |
| <title>HTMLTableElement24</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteTFoot() method deletes the footer from the table. |
| The deleteTFoot() method will delete the TFOOT Element from the |
| second TABLE element. First make sure that the TFOOT element exists |
| and then count the number of rows. After the TFOOT element is |
| deleted there should be one less row. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-78363258"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection1" type="HTMLTableElement" /> |
| <var name="vsection2" type="HTMLTableElement" /> |
| <var name="vrows" type="int"/> |
| <var name="doc" type="Document"/> |
| <var name="result" type="List"/> |
| <var name="expectedResult" type="List"> |
| <member>4</member> |
| <member>3</member> |
| </var> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection1"/> |
| <assertNotNull actual="vsection1" id="vsection1Id"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <append collection="result" item="vrows"/> |
| <deleteTFoot obj="testNode" interface="HTMLTableElement"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection2"/> |
| <rows interface="HTMLTableElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <append collection="result" item="vrows"/> |
| <assertEquals actual="result" expected="expectedResult" id="rowsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement25.xml.kfail |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement25"> |
| <metadata> |
| <title>HTMLTableElement25</title> |
| <creator>NIST</creator> |
| <description> |
| The createCaption() method creates a new table caption object or returns |
| an existing one. |
| Create a new CAPTION element on the first TABLE element. Since |
| one does not currently exist the CAPTION element is created. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-96920263"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection1" type="HTMLTableCaptionElement" /> |
| <var name="vsection2" type="HTMLTableCaptionElement" /> |
| <var name="newCaption" type="HTMLElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <caption interface="HTMLTableElement" obj="testNode" var="vsection1"/> |
| <assertNull actual="vsection1" id="vsection1Id"/> |
| <createCaption interface="HTMLTableElement" obj="testNode" var="newCaption"/> |
| <caption interface="HTMLTableElement" obj="testNode" var="vsection2"/> |
| <assertNotNull actual="vsection2" id="vsection2Id"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement26.xml.kfail |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement26"> |
| <metadata> |
| <title>HTMLTableElement26</title> |
| <creator>NIST</creator> |
| <description> |
| The createCaption() method creates a new table caption object or returns |
| an existing one. |
| Create a new CAPTION element on the first TABLE element. Since |
| one currently exists the CAPTION element is not created and you |
| can get the align attribute from the CAPTION element that exists. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-96920263"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection1" type="HTMLTableSectionElement" /> |
| <var name="vcaption" type="HTMLTableCaptionElement" /> |
| <var name="newCaption" type="HTMLElement" /> |
| <var name="valign" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <caption interface="HTMLTableElement" obj="testNode" var="vsection1"/> |
| <assertNotNull actual="vsection1" id="vsection1Id"/> |
| <createCaption interface="HTMLTableElement" obj="testNode" var="newCaption"/> |
| <caption interface="HTMLTableElement" obj="testNode" var="vcaption"/> |
| <align interface="HTMLTableCaptionElement" obj="vcaption" var="valign"/> |
| <assertEquals actual="valign" expected='"top"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement27.xml.kfail |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement27"> |
| <metadata> |
| <title>HTMLTableElement27</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteCaption() method deletes the table caption. |
| Delete the CAPTION element on the second TABLE element. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-22930071"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection1" type="HTMLTableSectionElement" /> |
| <var name="vsection2" type="HTMLTableSectionElement" /> |
| <var name="valign" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <caption interface="HTMLTableElement" obj="testNode" var="vsection1"/> |
| <assertNotNull actual="vsection1" id="vsection1Id"/> |
| <deleteCaption interface="HTMLTableElement" obj="testNode"/> |
| <caption interface="HTMLTableElement" obj="testNode" var="vsection2"/> |
| <assertNull actual="vsection2" id="vsection2Id"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement28.xml.kfail |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement28"> |
| <metadata> |
| <title>HTMLTableElement28</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. |
| Retrieve the second TABLE element and invoke the insertRow() method |
| with an index of 0. Currently the zero indexed row is in the THEAD |
| section of the TABLE. The number of rows in the THEAD section before |
| insertion of the new row is one. After the new row is inserted the number |
| of rows in the THEAD section is two. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39872903"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vsection1" type="HTMLTableSectionElement"/> |
| <var name="vsection2" type="HTMLTableSectionElement"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection1"/> |
| <rows interface="HTMLTableSectionElement" obj="vsection1" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink1" ignoreCase="false"/> |
| <insertRow interface="HTMLTableElement" obj="testNode" var="newRow" index="0"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection2"/> |
| <rows interface="HTMLTableSectionElement" obj="vsection2" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement29.xml.kfail |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement29"> |
| <metadata> |
| <title>HTMLTableElement29</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. |
| Retrieve the second TABLE element and invoke the insertRow() method |
| with an index of two. Currently the 2nd indexed row is in the TBODY |
| section of the TABLE. The number of rows in the TBODY section before |
| insertion of the new row is two. After the new row is inserted the number |
| of rows in the TBODY section is three. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39872903"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="tbodiesnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="bodyNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vsection1" type="HTMLTableSectionElement"/> |
| <var name="vsection2" type="HTMLTableSectionElement"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tBodies interface="HTMLTableElement" obj="testNode" var="tbodiesnodeList"/> |
| <item interface="HTMLCollection" obj="tbodiesnodeList" var="bodyNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="bodyNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink1" ignoreCase="false"/> |
| <insertRow interface="HTMLTableElement" obj="testNode" var="newRow" index="2"/> |
| <tBodies interface="HTMLTableElement" obj="testNode" var="tbodiesnodeList"/> |
| <item interface="HTMLCollection" obj="tbodiesnodeList" var="bodyNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="bodyNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="3" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement30.xml.kfail |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement30"> |
| <metadata> |
| <title>HTMLTableElement30</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. |
| Retrieve the second TABLE element and invoke the insertRow() method |
| with an index of four. After the new row is inserted the number of rows |
| in the table should be five. |
| Also the number of rows in the TFOOT section before |
| insertion of the new row is one. After the new row is inserted the number |
| of rows in the TFOOT section is two. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39872903"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="tbodiesnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vsection1" type="HTMLTableSectionElement"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="4" id="rowsLink1" ignoreCase="false"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection1"/> |
| <rows interface="HTMLTableSectionElement" obj="vsection1" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink" ignoreCase="false"/> |
| <insertRow interface="HTMLTableElement" obj="testNode" var="newRow" index="4"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="5" id="rowsLink2" ignoreCase="false"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection1"/> |
| <rows interface="HTMLTableSectionElement" obj="vsection1" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink3" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement31.xml.kfail |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement31"> |
| <metadata> |
| <title>HTMLTableElement31</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. In addition, when |
| the table is empty the row is inserted into a TBODY which is created |
| and inserted into the table. |
| Load the table1 file which has a non-empty table element. |
| Create an empty TABLE element and append to the document. |
| Check to make sure that the empty TABLE element doesn't |
| have a TBODY element. Insert a new row into the empty |
| TABLE element. Check for existence of the a TBODY element |
| in the table. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39872903"/> |
| <!-- comments on the commented out sections --> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2002Aug/0019.html"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=502"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="tableNode" type="Node"/> |
| <var name="tbodiesnodeList" type="HTMLCollection"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="doc" type="Document"/> |
| <var name="table" type="Element"/> |
| <var name="tbodiesLength" type="int"/> |
| <load var="doc" href="table1" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"body"'/> |
| <assertSize collection="nodeList" size="1" id="tableSize1"/> |
| <item interface="NodeList" obj="nodeList" index="0" var="testNode"/> |
| <createElement obj="doc" var="table" tagName='"table"'/> |
| <appendChild obj="testNode" newChild="table" var="tableNode"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="tableSize2"/> |
| <tBodies interface="HTMLTableElement" obj="tableNode" var="tbodiesnodeList"/> |
| <length var="tbodiesLength" obj="tbodiesnodeList" interface="HTMLCollection"/> |
| <assertEquals actual="tbodiesLength" expected="0" id="Asize3" ignoreCase="false"/> |
| <insertRow interface="HTMLTableElement" obj="tableNode" var="newRow" index="0"/> |
| <tBodies interface="HTMLTableElement" obj="tableNode" var="tbodiesnodeList"/> |
| <length var="tbodiesLength" obj="tbodiesnodeList" interface="HTMLCollection"/> |
| <assertEquals actual="tbodiesLength" expected="1" id="Asize4" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement32.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement32"> |
| <metadata> |
| <title>HTMLTableElement32</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method deletes a table row. |
| Retrieve the second TABLE element and invoke the deleteRow() method |
| with an index of 0(first row). Currently there are four rows in the |
| table. After the deleteRow() method is called there should be |
| three rows in the table. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-13114938"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="4" id="rowsLink1" ignoreCase="false"/> |
| <deleteRow interface="HTMLTableElement" obj="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="3" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableElement33.xml.kfail |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableElement33"> |
| <metadata> |
| <title>HTMLTableElement33</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method deletes a table row. |
| Retrieve the second TABLE element and invoke the deleteRow() method |
| with an index of 3(last row). Currently there are four rows in the |
| table. The deleteRow() method is called and now there should be three. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-13114938"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="4" id="rowsLink1" ignoreCase="false"/> |
| <deleteRow interface="HTMLTableElement" obj="testNode" index="3"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="3" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement01.xml.kfail |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement01"> |
| <metadata> |
| <title>HTMLTableRowElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The rowIndex attribute specifies the index of the row, relative to the |
| entire table, starting from 0. This is in document tree order and |
| not display order. The rowIndex does not take into account sections |
| (THEAD, TFOOT, or TBODY) within the table. |
| Retrieve the third TR element within the document and examine |
| its rowIndex value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-67347567"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrowindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <rowIndex interface="HTMLTableRowElement" obj="testNode" var="vrowindex"/> |
| <assertEquals actual="vrowindex" expected="1" id="rowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement02.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement02"> |
| <metadata> |
| <title>HTMLTableRowElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The sectionRowIndex attribute specifies the index of this row, relative |
| to the current section(THEAD, TFOOT, or TBODY),starting from 0. |
| Retrieve the second TR(1st In THEAD) element within the document and |
| examine its sectionRowIndex value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-79105901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsectionrowindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <sectionRowIndex interface="HTMLTableRowElement" obj="testNode" var="vsectionrowindex"/> |
| <assertEquals actual="vsectionrowindex" expected="0" id="sectionRowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement03.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement03"> |
| <metadata> |
| <title>HTMLTableRowElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The sectionRowIndex attribute specifies the index of this row, relative |
| to the current section(THEAD, TFOOT, or TBODY),starting from 0. |
| Retrieve the third TR(1st In TFOOT) element within the document and |
| examine its sectionRowIndex value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-79105901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsectionrowindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="2"/> |
| <sectionRowIndex interface="HTMLTableRowElement" obj="testNode" var="vsectionrowindex"/> |
| <assertEquals actual="vsectionrowindex" expected="0" id="sectionRowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement04.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement04"> |
| <metadata> |
| <title>HTMLTableRowElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The sectionRowIndex attribute specifies the index of this row, relative |
| to the current section(THEAD, TFOOT, or TBODY),starting from 0. |
| Retrieve the fifth TR(2nd In TBODY) element within the document and |
| examine its sectionRowIndex value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-79105901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsectionrowindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="4"/> |
| <sectionRowIndex interface="HTMLTableRowElement" obj="testNode" var="vsectionrowindex"/> |
| <assertEquals actual="vsectionrowindex" expected="1" id="sectionRowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement05.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement05"> |
| <metadata> |
| <title>HTMLTableRowElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The cells attribute specifies the collection of cells in this row. |
| Retrieve the fourth TR element and examine the value of |
| the cells length attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-67349879"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="cellsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcells" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="6" id="cellsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement06.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement06"> |
| <metadata> |
| <title>HTMLTableRowElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal alignment of data within |
| cells of this row. |
| Retrieve the align attribute of the second TR element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-74098257"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <align interface="HTMLTableRowElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement07.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement07"> |
| <metadata> |
| <title>HTMLTableRowElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The bgColor attribute specifies the background color of rows. |
| Retrieve the bgColor attribute of the second TR element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-18161327"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vbgcolor" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <bgColor interface="HTMLTableRowElement" obj="testNode" var="vbgcolor"/> |
| <assertEquals actual="vbgcolor" expected='"#00FFFF"' id="bgColorLink" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement08.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement08"> |
| <metadata> |
| <title>HTMLTableRowElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The ch attribute specifies the alignment character for cells in a column. |
| Retrieve the char attribute of the second TR element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-16230502"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <ch interface="HTMLTableRowElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='"*"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement09.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement09"> |
| <metadata> |
| <title>HTMLTableRowElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The chOff attribute specifies the offset of alignment character. |
| Retrieve the charoff attribute of the second TR element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-68207461"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vchoff" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <chOff interface="HTMLTableRowElement" obj="testNode" var="vchoff"/> |
| <assertEquals actual="vchoff" expected='"1"' id="charOffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement10.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement10"> |
| <metadata> |
| <title>HTMLTableRowElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The vAlign attribute specifies the vertical alignment of data within |
| cells of this row. |
| Retrieve the vAlign attribute of the second TR element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-90000058"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <vAlign interface="HTMLTableRowElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement11.xml.kfail |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement11"> |
| <metadata> |
| <title>HTMLTableRowElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The insertCell() method inserts an empty TD cell into this row. |
| Retrieve the fourth TR element and examine the value of |
| the cells length attribute which should be set to six. |
| Check the value of the first TD element. Invoke the |
| insertCell() which will create an empty TD cell at the |
| zero index position. Check the value of the newly created |
| cell and make sure it is null and also the numbers of cells |
| should now be seven. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-06</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-68927016"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="cellsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="trNode" type="Node"/> |
| <var name="cellNode" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <var name="newCell" type="HTMLElement"/> |
| <var name="vcells" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="6" id="cellsLink1" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="0"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <nodeValue obj="cellNode" var="value"/> |
| <assertEquals actual="value" expected='"EMP0001"' id="value1Link" ignoreCase="false"/> |
| <insertCell interface="HTMLTableRowElement" obj="testNode" var="newCell" index="0"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="7" id="cellsLink2" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="0"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <assertNull actual="cellNode" id="value2Link"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement12.xml.kfail |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement12"> |
| <metadata> |
| <title>HTMLTableRowElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The insertCell() method inserts an empty TD cell into this row. |
| Retrieve the fourth TR element and examine the value of |
| the cells length attribute which should be set to six. |
| Check the value of the last TD element. Invoke the |
| insertCell() which will append the empty cell to the end of the list. |
| Check the value of the newly created cell and make sure it is null |
| and also the numbers of cells should now be seven. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-06</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-68927016"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="cellsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="trNode" type="Node"/> |
| <var name="cellNode" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <var name="newCell" type="HTMLElement"/> |
| <var name="vcells" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="6" id="cellsLink1" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="5"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <nodeValue obj="cellNode" var="value"/> |
| <assertEquals actual="value" expected='"1230 North Ave. Dallas, Texas 98551"' id="value1Link" ignoreCase="false"/> |
| <insertCell interface="HTMLTableRowElement" obj="testNode" var="newCell" index="6"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="7" id="cellsLink2" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="6"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <assertNull actual="cellNode" id="value2Link"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement13.xml.kfail |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement13"> |
| <metadata> |
| <title>HTMLTableRowElement13</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteCell() method deletes a cell from the current row. |
| Retrieve the fourth TR element and examine the value of |
| the cells length attribute which should be set to six. |
| Check the value of the first TD element. Invoke the |
| deleteCell() method which will delete a cell from the current row. |
| Check the value of the cell at the zero index and also check |
| the number of cells which should now be five. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-06</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-11738598"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="cellsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="trNode" type="Node"/> |
| <var name="cellNode" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <var name="vcells" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="6" id="cellsLink1" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="0"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <nodeValue obj="cellNode" var="value"/> |
| <assertEquals actual="value" expected='"EMP0001"' id="value1Link" ignoreCase="false"/> |
| <deleteCell interface="HTMLTableRowElement" obj="testNode" index="0"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="5" id="cellsLink2" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="0"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <nodeValue obj="cellNode" var="value"/> |
| <assertEquals actual="value" expected='"Margaret Martin"' id="value2Link" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableRowElement14.xml.kfail |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableRowElement14"> |
| <metadata> |
| <title>HTMLTableRowElement14</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteCell() method deletes a cell from the current row. |
| Retrieve the fourth TR element and examine the value of |
| the cells length attribute which should be set to six. |
| Check the value of the third(index 2) TD element. Invoke the |
| deleteCell() method which will delete a cell from the current row. |
| Check the value of the third cell(index 2) and also check |
| the number of cells which should now be five. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-06</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-11738598"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="cellsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="trNode" type="Node"/> |
| <var name="cellNode" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <var name="vcells" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="6" id="cellsLink1" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="2"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <nodeValue obj="cellNode" var="value"/> |
| <assertEquals actual="value" expected='"Accountant"' id="value1Link" ignoreCase="false"/> |
| <deleteCell interface="HTMLTableRowElement" obj="testNode" index="2"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="5" id="cellsLink2" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="2"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <nodeValue obj="cellNode" var="value"/> |
| <assertEquals actual="value" expected='"56,000"' id="value2Link" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement01.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement01"> |
| <metadata> |
| <title>HTMLTableSectionElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal alignment of data within |
| cells. |
| Retrieve the align attribute of the first THEAD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-40530119"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLTableSectionElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement02.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement02"> |
| <metadata> |
| <title>HTMLTableSectionElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal alignment of data within |
| cells. |
| Retrieve the align attribute of the first TFOOT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-40530119"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tfoot"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLTableSectionElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement03.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement03"> |
| <metadata> |
| <title>HTMLTableSectionElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The align attribute specifies the horizontal alignment of data within |
| cells. |
| Retrieve the align attribute of the first TBODY element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-40530119"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tbody"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <align interface="HTMLTableSectionElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement04.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement04"> |
| <metadata> |
| <title>HTMLTableSectionElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The ch attribute specifies the alignment character for cells in a |
| column. |
| Retrieve the char attribute of the first THEAD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83470012"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <ch interface="HTMLTableSectionElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='"*"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement05.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement05"> |
| <metadata> |
| <title>HTMLTableSectionElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The ch attribute specifies the alignment character for cells in a |
| column. |
| Retrieve the char attribute of the first TFOOT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83470012"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tfoot"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <ch interface="HTMLTableSectionElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='"+"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement06.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement06"> |
| <metadata> |
| <title>HTMLTableSectionElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The ch attribute specifies the alignment character for cells in a |
| column. |
| Retrieve the char attribute of the first TBODY element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83470012"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tbody"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <ch interface="HTMLTableSectionElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='"$"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement07.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement07"> |
| <metadata> |
| <title>HTMLTableSectionElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The chOff attribute specifies the offset of alignment character. |
| Retrieve the charoff attribute of the first THEAD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-53459732"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcharoff" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <chOff interface="HTMLTableSectionElement" obj="testNode" var="vcharoff"/> |
| <assertEquals actual="vcharoff" expected='"1"' id="chOffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement08.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement08"> |
| <metadata> |
| <title>HTMLTableSectionElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The chOff attribute specifies the offset of alignment character. |
| Retrieve the charoff attribute of the first TFOOT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-53459732"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcharoff" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tfoot"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <chOff interface="HTMLTableSectionElement" obj="testNode" var="vcharoff"/> |
| <assertEquals actual="vcharoff" expected='"2"' id="chOffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement09.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement09"> |
| <metadata> |
| <title>HTMLTableSectionElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The chOff attribute specifies the offset of alignment character. |
| Retrieve the charoff attribute of the first TBODY element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-53459732"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcharoff" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tbody"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <chOff interface="HTMLTableSectionElement" obj="testNode" var="vcharoff"/> |
| <assertEquals actual="vcharoff" expected='"3"' id="chOffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement10.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement10"> |
| <metadata> |
| <title>HTMLTableSectionElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The vAlign attribute specifies the vertical alignment of cell data in |
| column. |
| Retrieve the vAlign attribute of the first THEAD element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-4379116"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vAlign interface="HTMLTableSectionElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement11.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement11"> |
| <metadata> |
| <title>HTMLTableSectionElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The vAlign attribute specifies the vertical alignment of cell data in |
| column. |
| Retrieve the vAlign attribute of the first TFOOT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-4379116"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tfoot"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vAlign interface="HTMLTableSectionElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement12.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement12"> |
| <metadata> |
| <title>HTMLTableSectionElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The vAlign attribute specifies the vertical alignment of cell data in |
| column. |
| Retrieve the vAlign attribute of the first TBODY element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-4379116"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tbody"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <vAlign interface="HTMLTableSectionElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement13.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement13"> |
| <metadata> |
| <title>HTMLTableSectionElement13</title> |
| <creator>NIST</creator> |
| <description> |
| The rows attribute specifies the collection of rows in this table section. |
| Retrieve the first THEAD element and examine the value of |
| the rows length attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52092650"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement14.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement14"> |
| <metadata> |
| <title>HTMLTableSectionElement14</title> |
| <creator>NIST</creator> |
| <description> |
| The rows attribute specifies the collection of rows in this table section. |
| Retrieve the first TFOOT element and examine the value of |
| the rows length attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52092650"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tfoot"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement15.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement15"> |
| <metadata> |
| <title>HTMLTableSectionElement15</title> |
| <creator>NIST</creator> |
| <description> |
| The rows attribute specifies the collection of rows in this table section. |
| Retrieve the first TBODY element and examine the value of |
| the rows length attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-52092650"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tbody"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement16.xml.kfail |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement16"> |
| <metadata> |
| <title>HTMLTableSectionElement16</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. |
| Retrieve the first THEAD element and invoke the insertRow() method |
| with an index of 0. The nuber of rows in the THEAD section before |
| insertion of the new row is one. After the new row is inserted the number |
| of rows in the THEAD section is two. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-93995626"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink1" ignoreCase="false"/> |
| <insertRow interface="HTMLTableSectionElement" obj="testNode" var="newRow" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement17.xml.kfail |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement17"> |
| <metadata> |
| <title>HTMLTableSectionElement17</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. |
| Retrieve the first TFOOT element and invoke the insertRow() method |
| with an index of 0. The nuber of rows in the TFOOT section before |
| insertion of the new row is one. After the new row is inserted the number |
| of rows in the TFOOT section is two. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-93995626"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tfoot"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink1" ignoreCase="false"/> |
| <insertRow interface="HTMLTableSectionElement" obj="testNode" var="newRow" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement18.xml.kfail |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement18"> |
| <metadata> |
| <title>HTMLTableSectionElement18</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. |
| Retrieve the first TBODY element and invoke the insertRow() method |
| with an index of 0. The nuber of rows in the TBODY section before |
| insertion of the new row is two. After the new row is inserted the number |
| of rows in the TBODY section is three. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-93995626"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tbody"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink1" ignoreCase="false"/> |
| <insertRow interface="HTMLTableSectionElement" obj="testNode" var="newRow" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="3" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement19.xml.kfail |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement19"> |
| <metadata> |
| <title>HTMLTableSectionElement19</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. |
| Retrieve the first THEAD element and invoke the insertRow() method |
| with an index of 1. The nuber of rows in the THEAD section before |
| insertion of the new row is one therefore the new row is appended. |
| After the new row is inserted the number of rows in the THEAD |
| section is two. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-93995626"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink1" ignoreCase="false"/> |
| <insertRow interface="HTMLTableSectionElement" obj="testNode" var="newRow" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement20.xml.kfail |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement20"> |
| <metadata> |
| <title>HTMLTableSectionElement20</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. |
| Retrieve the first TFOOT element and invoke the insertRow() method |
| with an index of one. The nuber of rows in the TFOOT section before |
| insertion of the new row is one therefore the new row is appended. |
| After the new row is inserted the number of rows in the TFOOT section |
| is two. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-93995626"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tfoot"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink1" ignoreCase="false"/> |
| <insertRow interface="HTMLTableSectionElement" obj="testNode" var="newRow" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement21.xml.kfail |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement21"> |
| <metadata> |
| <title>HTMLTableSectionElement21</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. |
| Retrieve the first TBODY element and invoke the insertRow() method |
| with an index of two. The number of rows in the TBODY section before |
| insertion of the new row is two therefore the row is appended. |
| After the new row is inserted the number of rows in the TBODY section is |
| three. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-93995626"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=502"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tbody"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink1" ignoreCase="false"/> |
| <insertRow interface="HTMLTableSectionElement" obj="testNode" var="newRow" index="2"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="3" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement22.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement22"> |
| <metadata> |
| <title>HTMLTableSectionElement22</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method deletes a row from this section. |
| Retrieve the first THEAD element and invoke the deleteRow() method |
| with an index of 0. The nuber of rows in the THEAD section before |
| the deletion of the row is one. After the row is deleted the number |
| of rows in the THEAD section is zero. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-5625626"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink1" ignoreCase="false"/> |
| <deleteRow interface="HTMLTableSectionElement" obj="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="0" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement23.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement23"> |
| <metadata> |
| <title>HTMLTableSectionElement23</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method deletes a row from this section. |
| Retrieve the first TFOOT element and invoke the deleteRow() method |
| with an index of 0. The nuber of rows in the TFOOT section before |
| the deletion of the row is one. After the row is deleted the number |
| of rows in the TFOOT section is zero. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-5625626"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tfoot"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink1" ignoreCase="false"/> |
| <deleteRow interface="HTMLTableSectionElement" obj="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="0" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTableSectionElement24.xml.kfail |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTableSectionElement24"> |
| <metadata> |
| <title>HTMLTableSectionElement24</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method deletes a row from this section. |
| Retrieve the first TBODY element and invoke the deleteRow() method |
| with an index of 0. The nuber of rows in the TBODY section before |
| the deletion of the row is two. After the row is deleted the number |
| of rows in the TBODY section is one. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-5625626"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tbody"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink1" ignoreCase="false"/> |
| <deleteRow interface="HTMLTableSectionElement" obj="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement01.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement01"> |
| <metadata> |
| <title>HTMLTextAreaElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The defaultValue attribute represents the HTML value of the attribute |
| when the type attribute has the value of "Text", "File" or "Password". |
| Retrieve the defaultValue attribute of the 2nd TEXTAREA element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-36152213"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdefaultvalue" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <defaultValue interface="HTMLTextAreaElement" obj="testNode" var="vdefaultvalue"/> |
| <assertEquals actual="vdefaultvalue" expected='"TEXTAREA2"' id="defaultValueLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement02.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement02"> |
| <metadata> |
| <title>HTMLTextAreaElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns the FORM element containing this control. |
| Retrieve the form attribute from the first TEXTAREA element |
| and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-18911464"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="DOMString" /> |
| <var name="fNode" type="HTMLFormElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLTextAreaElement" obj="testNode" var="fNode"/> |
| <id obj="fNode" var="vform"/> |
| <assertEquals actual="vform" expected='"form1"' id="formLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement03.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement03"> |
| <metadata> |
| <title>HTMLTextAreaElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The form attribute returns null if control in not within the context of |
| a form. |
| Retrieve the second TEXTAREA element and |
| examine its form element. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-18911464"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="HTMLFormElement" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <form interface="HTMLTextAreaElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formNullLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement04.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement04"> |
| <metadata> |
| <title>HTMLTextAreaElement04</title> |
| <creator>NIST</creator> |
| <description> |
| The accessKey attribute specifies a single character access key to |
| give access to the form control. |
| Retrieve the accessKey attribute of the 1st TEXTAREA element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-93102991"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaccesskey" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <accessKey interface="HTMLTextAreaElement" obj="testNode" var="vaccesskey"/> |
| <assertEquals actual="vaccesskey" expected='"c"' id="accessKeyLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement05.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement05"> |
| <metadata> |
| <title>HTMLTextAreaElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The cols attribute specifies the width of control(in characters). |
| Retrieve the cols attribute of the 1st TEXTAREA element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-51387225"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcols" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <cols interface="HTMLTextAreaElement" obj="testNode" var="vcols"/> |
| <assertEquals actual="vcols" expected="20" id="colsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement06.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement06"> |
| <metadata> |
| <title>HTMLTextAreaElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The disabled attribute specifies the control is unavailable in this |
| context. |
| Retrieve the disabled attribute from the 2nd TEXTAREA element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-98725443"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdisabled" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <disabled interface="HTMLTextAreaElement" obj="testNode" var="vdisabled"/> |
| <assertTrue actual="vdisabled" id="disabledLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement07.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement07"> |
| <metadata> |
| <title>HTMLTextAreaElement07</title> |
| <creator>NIST</creator> |
| <description> |
| The name attribute specifies the form control or object name when |
| submitted with a form. |
| Retrieve the name attribute of the 1st TEXTAREA element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-70715578"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vname" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <name interface="HTMLTextAreaElement" obj="testNode" var="vname"/> |
| <assertEquals actual="vname" expected='"text1"' id="nameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement08.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement08"> |
| <metadata> |
| <title>HTMLTextAreaElement08</title> |
| <creator>NIST</creator> |
| <description> |
| The readOnly attribute specifies this control is read-only. |
| Retrieve the readOnly attribute from the 3rd TEXTAREA element and |
| examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39131423"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vreadonly" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="2"/> |
| <readOnly interface="HTMLTextAreaElement" obj="testNode" var="vreadonly"/> |
| <assertTrue actual="vreadonly" id="readOnlyLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement09.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement09"> |
| <metadata> |
| <title>HTMLTextAreaElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The rows attribute specifies the number of text rowns. |
| Retrieve the rows attribute of the 1st TEXTAREA element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-46975887"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTextAreaElement" obj="testNode" var="vrows"/> |
| <assertEquals actual="vrows" expected="7" id="rowsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement10.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement10"> |
| <metadata> |
| <title>HTMLTextAreaElement10</title> |
| <creator>NIST</creator> |
| <description> |
| The tabIndex attribute is an index that represents the element's position |
| in the tabbing order. |
| Retrieve the tabIndex attribute of the 1st TEXTAREA element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-60363303"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtabindex" type="int" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tabIndex interface="HTMLTextAreaElement" obj="testNode" var="vtabindex"/> |
| <assertEquals actual="vtabindex" expected="5" id="tabIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement11.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement11"> |
| <metadata> |
| <title>HTMLTextAreaElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute specifies the type of this form control. |
| Retrieve the type attribute of the 1st TEXTAREA element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <!-- L1 HTML doesn't have an ID for the type attribute --> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-24874179"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#HTML-HTMLTextAreaElement-type"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLTextAreaElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"textarea"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement12.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement12"> |
| <metadata> |
| <title>HTMLTextAreaElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The value attribute represents the current contents of the corresponding |
| form control, in an interactive user agent. |
| Retrieve the value attribute of the 1st TEXTAREA element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-70715579"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalue" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <value interface="HTMLTextAreaElement" obj="testNode" var="vvalue"/> |
| <assertEquals actual="vvalue" expected='"TEXTAREA1"' id="valueLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement13.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement13"> |
| <metadata> |
| <title>HTMLTextAreaElement13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Calling HTMLTextAreaElement.blur should surrender input focus. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6750689"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <blur interface="HTMLTextAreaElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement14.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement14"> |
| <metadata> |
| <title>HTMLTextAreaElement14</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Calling HTMLTextAreaElement.focus should capture input focus. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39055426"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <focus interface="HTMLTextAreaElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTextAreaElement15.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTextAreaElement15"> |
| <metadata> |
| <title>HTMLTextAreaElement15</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Calling HTMLTextAreaElement.select should select the text area. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-48880622"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="textarea" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"textarea"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <select interface="HTMLTextAreaElement" obj="testNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLTitleElement01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLTitleElement01"> |
| <metadata> |
| <title>HTMLTitleElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The text attribute is the specified title as a string. |
| Retrieve the text attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-77500413"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtext" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="title" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"title"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <text interface="HTMLTitleElement" obj="testNode" var="vtext"/> |
| <assertEquals actual="vtext" expected='"NIST DOM HTML Test - TITLE"' id="textLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLUListElement01.xml.kfail |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLUListElement01"> |
| <metadata> |
| <title>HTMLUListElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The compact attribute specifies whether to reduce spacing between list |
| items. |
| Retrieve the compact attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39864178"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcompact" type="boolean" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="ulist" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"ul"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <compact interface="HTMLUListElement" obj="testNode" var="vcompact"/> |
| <assertTrue actual="vcompact" id="compactLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/HTMLUListElement02.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="HTMLUListElement02"> |
| <metadata> |
| <title>HTMLUListElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The type attribute specifies the bullet style. |
| Retrieve the type attribute and examine its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-02-22</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-96874670"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="ulist" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"ul"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLUListElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"disc"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/alltests.xml |
|---|
| 0,0 → 1,659 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE suite SYSTEM "dom1.dtd"> |
| <suite xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="alltests"> |
| <metadata> |
| <title>DOM Level 1 HTML Test Suite</title> |
| <creator>DOM Test Suite Project</creator> |
| </metadata> |
| <suite.member href="HTMLAnchorElement01.xml"/> |
| <suite.member href="HTMLAnchorElement02.xml"/> |
| <suite.member href="HTMLAnchorElement03.xml"/> |
| <suite.member href="HTMLAnchorElement04.xml"/> |
| <suite.member href="HTMLAnchorElement05.xml"/> |
| <suite.member href="HTMLAnchorElement06.xml"/> |
| <suite.member href="HTMLAnchorElement07.xml"/> |
| <suite.member href="HTMLAnchorElement08.xml"/> |
| <suite.member href="HTMLAnchorElement09.xml"/> |
| <suite.member href="HTMLAnchorElement10.xml"/> |
| <suite.member href="HTMLAnchorElement11.xml"/> |
| <suite.member href="HTMLAnchorElement12.xml"/> |
| <suite.member href="HTMLAnchorElement13.xml"/> |
| <suite.member href="HTMLAnchorElement14.xml"/> |
| <suite.member href="HTMLAppletElement01.xml"/> |
| <suite.member href="HTMLAppletElement02.xml"/> |
| <suite.member href="HTMLAppletElement03.xml"/> |
| <suite.member href="HTMLAppletElement04.xml"/> |
| <suite.member href="HTMLAppletElement05.xml"/> |
| <suite.member href="HTMLAppletElement06.xml"/> |
| <suite.member href="HTMLAppletElement07.xml"/> |
| <suite.member href="HTMLAppletElement08.xml"/> |
| <suite.member href="HTMLAppletElement09.xml"/> |
| <suite.member href="HTMLAppletElement10.xml"/> |
| <suite.member href="HTMLAppletElement11.xml"/> |
| <suite.member href="HTMLAreaElement01.xml"/> |
| <suite.member href="HTMLAreaElement02.xml"/> |
| <suite.member href="HTMLAreaElement03.xml"/> |
| <suite.member href="HTMLAreaElement04.xml"/> |
| <suite.member href="HTMLAreaElement05.xml"/> |
| <suite.member href="HTMLAreaElement06.xml"/> |
| <suite.member href="HTMLAreaElement07.xml"/> |
| <suite.member href="HTMLAreaElement08.xml"/> |
| <suite.member href="HTMLBaseElement01.xml"/> |
| <suite.member href="HTMLBaseElement02.xml"/> |
| <suite.member href="HTMLBaseFontElement01.xml"/> |
| <suite.member href="HTMLBaseFontElement02.xml"/> |
| <suite.member href="HTMLBaseFontElement03.xml"/> |
| <suite.member href="HTMLBodyElement01.xml"/> |
| <suite.member href="HTMLBodyElement02.xml"/> |
| <suite.member href="HTMLBodyElement03.xml"/> |
| <suite.member href="HTMLBodyElement04.xml"/> |
| <suite.member href="HTMLBodyElement05.xml"/> |
| <suite.member href="HTMLBodyElement06.xml"/> |
| <suite.member href="HTMLBRElement01.xml"/> |
| <suite.member href="HTMLButtonElement01.xml"/> |
| <suite.member href="HTMLButtonElement02.xml"/> |
| <suite.member href="HTMLButtonElement03.xml"/> |
| <suite.member href="HTMLButtonElement04.xml"/> |
| <suite.member href="HTMLButtonElement05.xml"/> |
| <suite.member href="HTMLButtonElement06.xml"/> |
| <suite.member href="HTMLButtonElement07.xml"/> |
| <suite.member href="HTMLButtonElement08.xml"/> |
| <suite.member href="HTMLCollection01.xml"/> |
| <suite.member href="HTMLCollection02.xml"/> |
| <suite.member href="HTMLCollection03.xml"/> |
| <suite.member href="HTMLCollection04.xml"/> |
| <suite.member href="HTMLCollection05.xml"/> |
| <suite.member href="HTMLCollection06.xml"/> |
| <suite.member href="HTMLCollection07.xml"/> |
| <suite.member href="HTMLCollection08.xml"/> |
| <suite.member href="HTMLCollection09.xml"/> |
| <suite.member href="HTMLCollection10.xml"/> |
| <suite.member href="HTMLCollection11.xml"/> |
| <suite.member href="HTMLCollection12.xml"/> |
| <suite.member href="HTMLDirectoryElement01.xml"/> |
| <suite.member href="HTMLDivElement01.xml"/> |
| <suite.member href="HTMLDlistElement01.xml"/> |
| <suite.member href="HTMLDocument01.xml"/> |
| <suite.member href="HTMLDocument02.xml"/> |
| <suite.member href="HTMLDocument03.xml"/> |
| <suite.member href="HTMLDocument04.xml"/> |
| <suite.member href="HTMLDocument05.xml"/> |
| <suite.member href="HTMLDocument07.xml"/> |
| <suite.member href="HTMLDocument08.xml"/> |
| <suite.member href="HTMLDocument09.xml"/> |
| <suite.member href="HTMLDocument10.xml"/> |
| <suite.member href="HTMLDocument11.xml"/> |
| <suite.member href="HTMLDocument12.xml"/> |
| <suite.member href="HTMLDocument13.xml"/> |
| <suite.member href="HTMLDocument14.xml"/> |
| <suite.member href="HTMLDocument15.xml"/> |
| <suite.member href="HTMLDocument16.xml"/> |
| <suite.member href="HTMLDocument17.xml"/> |
| <suite.member href="HTMLDocument18.xml"/> |
| <suite.member href="HTMLDocument19.xml"/> |
| <suite.member href="HTMLDocument20.xml"/> |
| <suite.member href="HTMLDocument21.xml"/> |
| <suite.member href="HTMLElement01.xml"/> |
| <suite.member href="HTMLElement02.xml"/> |
| <suite.member href="HTMLElement03.xml"/> |
| <suite.member href="HTMLElement04.xml"/> |
| <suite.member href="HTMLElement05.xml"/> |
| <suite.member href="HTMLElement06.xml"/> |
| <suite.member href="HTMLElement07.xml"/> |
| <suite.member href="HTMLElement08.xml"/> |
| <suite.member href="HTMLElement09.xml"/> |
| <suite.member href="HTMLElement10.xml"/> |
| <suite.member href="HTMLElement11.xml"/> |
| <suite.member href="HTMLElement12.xml"/> |
| <suite.member href="HTMLElement13.xml"/> |
| <suite.member href="HTMLElement14.xml"/> |
| <suite.member href="HTMLElement15.xml"/> |
| <suite.member href="HTMLElement16.xml"/> |
| <suite.member href="HTMLElement17.xml"/> |
| <suite.member href="HTMLElement18.xml"/> |
| <suite.member href="HTMLElement19.xml"/> |
| <suite.member href="HTMLElement20.xml"/> |
| <suite.member href="HTMLElement21.xml"/> |
| <suite.member href="HTMLElement22.xml"/> |
| <suite.member href="HTMLElement23.xml"/> |
| <suite.member href="HTMLElement24.xml"/> |
| <suite.member href="HTMLElement25.xml"/> |
| <suite.member href="HTMLElement26.xml"/> |
| <suite.member href="HTMLElement27.xml"/> |
| <suite.member href="HTMLElement28.xml"/> |
| <suite.member href="HTMLElement29.xml"/> |
| <suite.member href="HTMLElement30.xml"/> |
| <suite.member href="HTMLElement31.xml"/> |
| <suite.member href="HTMLElement32.xml"/> |
| <suite.member href="HTMLElement33.xml"/> |
| <suite.member href="HTMLElement34.xml"/> |
| <suite.member href="HTMLElement35.xml"/> |
| <suite.member href="HTMLElement36.xml"/> |
| <suite.member href="HTMLElement37.xml"/> |
| <suite.member href="HTMLElement38.xml"/> |
| <suite.member href="HTMLElement39.xml"/> |
| <suite.member href="HTMLElement40.xml"/> |
| <suite.member href="HTMLElement41.xml"/> |
| <suite.member href="HTMLElement42.xml"/> |
| <suite.member href="HTMLElement43.xml"/> |
| <suite.member href="HTMLElement44.xml"/> |
| <suite.member href="HTMLElement45.xml"/> |
| <suite.member href="HTMLElement46.xml"/> |
| <suite.member href="HTMLElement47.xml"/> |
| <suite.member href="HTMLElement48.xml"/> |
| <suite.member href="HTMLElement49.xml"/> |
| <suite.member href="HTMLElement50.xml"/> |
| <suite.member href="HTMLElement51.xml"/> |
| <suite.member href="HTMLElement52.xml"/> |
| <suite.member href="HTMLElement53.xml"/> |
| <suite.member href="HTMLElement54.xml"/> |
| <suite.member href="HTMLElement55.xml"/> |
| <suite.member href="HTMLElement56.xml"/> |
| <suite.member href="HTMLElement57.xml"/> |
| <suite.member href="HTMLElement58.xml"/> |
| <suite.member href="HTMLElement59.xml"/> |
| <suite.member href="HTMLElement60.xml"/> |
| <suite.member href="HTMLElement61.xml"/> |
| <suite.member href="HTMLElement62.xml"/> |
| <suite.member href="HTMLElement63.xml"/> |
| <suite.member href="HTMLElement64.xml"/> |
| <suite.member href="HTMLElement65.xml"/> |
| <suite.member href="HTMLElement66.xml"/> |
| <suite.member href="HTMLElement67.xml"/> |
| <suite.member href="HTMLElement68.xml"/> |
| <suite.member href="HTMLElement69.xml"/> |
| <suite.member href="HTMLElement70.xml"/> |
| <suite.member href="HTMLElement71.xml"/> |
| <suite.member href="HTMLElement72.xml"/> |
| <suite.member href="HTMLElement73.xml"/> |
| <suite.member href="HTMLElement74.xml"/> |
| <suite.member href="HTMLElement75.xml"/> |
| <suite.member href="HTMLElement76.xml"/> |
| <suite.member href="HTMLElement77.xml"/> |
| <suite.member href="HTMLElement78.xml"/> |
| <suite.member href="HTMLElement79.xml"/> |
| <suite.member href="HTMLElement80.xml"/> |
| <suite.member href="HTMLElement81.xml"/> |
| <suite.member href="HTMLElement82.xml"/> |
| <suite.member href="HTMLElement83.xml"/> |
| <suite.member href="HTMLElement84.xml"/> |
| <suite.member href="HTMLElement85.xml"/> |
| <suite.member href="HTMLElement86.xml"/> |
| <suite.member href="HTMLElement87.xml"/> |
| <suite.member href="HTMLElement88.xml"/> |
| <suite.member href="HTMLElement89.xml"/> |
| <suite.member href="HTMLElement90.xml"/> |
| <suite.member href="HTMLElement91.xml"/> |
| <suite.member href="HTMLElement92.xml"/> |
| <suite.member href="HTMLElement93.xml"/> |
| <suite.member href="HTMLElement94.xml"/> |
| <suite.member href="HTMLElement95.xml"/> |
| <suite.member href="HTMLElement96.xml"/> |
| <suite.member href="HTMLElement97.xml"/> |
| <suite.member href="HTMLElement98.xml"/> |
| <suite.member href="HTMLElement99.xml"/> |
| <suite.member href="HTMLElement100.xml"/> |
| <suite.member href="HTMLElement101.xml"/> |
| <suite.member href="HTMLElement102.xml"/> |
| <suite.member href="HTMLElement103.xml"/> |
| <suite.member href="HTMLElement104.xml"/> |
| <suite.member href="HTMLElement105.xml"/> |
| <suite.member href="HTMLElement106.xml"/> |
| <suite.member href="HTMLElement107.xml"/> |
| <suite.member href="HTMLElement108.xml"/> |
| <suite.member href="HTMLElement109.xml"/> |
| <suite.member href="HTMLElement110.xml"/> |
| <suite.member href="HTMLElement111.xml"/> |
| <suite.member href="HTMLElement112.xml"/> |
| <suite.member href="HTMLElement113.xml"/> |
| <suite.member href="HTMLElement114.xml"/> |
| <suite.member href="HTMLElement115.xml"/> |
| <suite.member href="HTMLElement116.xml"/> |
| <suite.member href="HTMLElement117.xml"/> |
| <suite.member href="HTMLElement118.xml"/> |
| <suite.member href="HTMLElement119.xml"/> |
| <suite.member href="HTMLElement120.xml"/> |
| <suite.member href="HTMLElement121.xml"/> |
| <suite.member href="HTMLElement122.xml"/> |
| <suite.member href="HTMLElement123.xml"/> |
| <suite.member href="HTMLElement124.xml"/> |
| <suite.member href="HTMLElement125.xml"/> |
| <suite.member href="HTMLElement126.xml"/> |
| <suite.member href="HTMLElement127.xml"/> |
| <suite.member href="HTMLElement128.xml"/> |
| <suite.member href="HTMLElement129.xml"/> |
| <suite.member href="HTMLElement130.xml"/> |
| <suite.member href="HTMLElement131.xml"/> |
| <suite.member href="HTMLElement132.xml"/> |
| <suite.member href="HTMLElement133.xml"/> |
| <suite.member href="HTMLElement134.xml"/> |
| <suite.member href="HTMLElement135.xml"/> |
| <suite.member href="HTMLElement136.xml"/> |
| <suite.member href="HTMLElement137.xml"/> |
| <suite.member href="HTMLElement138.xml"/> |
| <suite.member href="HTMLElement139.xml"/> |
| <suite.member href="HTMLElement140.xml"/> |
| <suite.member href="HTMLElement141.xml"/> |
| <suite.member href="HTMLElement142.xml"/> |
| <suite.member href="HTMLElement143.xml"/> |
| <suite.member href="HTMLElement144.xml"/> |
| <suite.member href="HTMLElement145.xml"/> |
| <suite.member href="HTMLFieldSetElement01.xml"/> |
| <suite.member href="HTMLFieldSetElement02.xml"/> |
| <suite.member href="HTMLFontElement01.xml"/> |
| <suite.member href="HTMLFontElement02.xml"/> |
| <suite.member href="HTMLFontElement03.xml"/> |
| <suite.member href="HTMLFormElement01.xml"/> |
| <suite.member href="HTMLFormElement02.xml"/> |
| <suite.member href="HTMLFormElement03.xml"/> |
| <suite.member href="HTMLFormElement04.xml"/> |
| <suite.member href="HTMLFormElement05.xml"/> |
| <suite.member href="HTMLFormElement06.xml"/> |
| <suite.member href="HTMLFormElement07.xml"/> |
| <suite.member href="HTMLFormElement08.xml"/> |
| <suite.member href="HTMLFormElement09.xml"/> |
| <suite.member href="HTMLFormElement10.xml"/> |
| <suite.member href="HTMLFrameElement01.xml"/> |
| <suite.member href="HTMLFrameElement02.xml"/> |
| <suite.member href="HTMLFrameElement03.xml"/> |
| <suite.member href="HTMLFrameElement04.xml"/> |
| <suite.member href="HTMLFrameElement05.xml"/> |
| <suite.member href="HTMLFrameElement06.xml"/> |
| <suite.member href="HTMLFrameElement07.xml"/> |
| <suite.member href="HTMLFrameElement08.xml"/> |
| <suite.member href="HTMLFrameSetElement01.xml"/> |
| <suite.member href="HTMLFrameSetElement02.xml"/> |
| <suite.member href="HTMLHeadElement01.xml"/> |
| <suite.member href="HTMLHeadingElement01.xml"/> |
| <suite.member href="HTMLHeadingElement02.xml"/> |
| <suite.member href="HTMLHeadingElement03.xml"/> |
| <suite.member href="HTMLHeadingElement04.xml"/> |
| <suite.member href="HTMLHeadingElement05.xml"/> |
| <suite.member href="HTMLHeadingElement06.xml"/> |
| <suite.member href="HTMLHRElement01.xml"/> |
| <suite.member href="HTMLHRElement02.xml"/> |
| <suite.member href="HTMLHRElement03.xml"/> |
| <suite.member href="HTMLHRElement04.xml"/> |
| <suite.member href="HTMLHtmlElement01.xml"/> |
| <suite.member href="HTMLIFrameElement01.xml"/> |
| <suite.member href="HTMLIFrameElement02.xml"/> |
| <suite.member href="HTMLIFrameElement03.xml"/> |
| <suite.member href="HTMLIFrameElement04.xml"/> |
| <suite.member href="HTMLIFrameElement05.xml"/> |
| <suite.member href="HTMLIFrameElement06.xml"/> |
| <suite.member href="HTMLIFrameElement07.xml"/> |
| <suite.member href="HTMLIFrameElement08.xml"/> |
| <suite.member href="HTMLIFrameElement09.xml"/> |
| <suite.member href="HTMLIFrameElement10.xml"/> |
| <suite.member href="HTMLImageElement01.xml"/> |
| <suite.member href="HTMLImageElement02.xml"/> |
| <suite.member href="HTMLImageElement03.xml"/> |
| <suite.member href="HTMLImageElement04.xml"/> |
| <suite.member href="HTMLImageElement05.xml"/> |
| <suite.member href="HTMLImageElement06.xml"/> |
| <suite.member href="HTMLImageElement07.xml"/> |
| <suite.member href="HTMLImageElement08.xml"/> |
| <suite.member href="HTMLImageElement09.xml"/> |
| <suite.member href="HTMLImageElement10.xml"/> |
| <suite.member href="HTMLImageElement11.xml"/> |
| <suite.member href="HTMLImageElement12.xml"/> |
| <suite.member href="HTMLImageElement14.xml"/> |
| <suite.member href="HTMLInputElement01.xml"/> |
| <suite.member href="HTMLInputElement02.xml"/> |
| <suite.member href="HTMLInputElement03.xml"/> |
| <suite.member href="HTMLInputElement04.xml"/> |
| <suite.member href="HTMLInputElement05.xml"/> |
| <suite.member href="HTMLInputElement06.xml"/> |
| <suite.member href="HTMLInputElement07.xml"/> |
| <suite.member href="HTMLInputElement08.xml"/> |
| <suite.member href="HTMLInputElement09.xml"/> |
| <suite.member href="HTMLInputElement10.xml"/> |
| <suite.member href="HTMLInputElement11.xml"/> |
| <suite.member href="HTMLInputElement12.xml"/> |
| <suite.member href="HTMLInputElement13.xml"/> |
| <suite.member href="HTMLInputElement14.xml"/> |
| <suite.member href="HTMLInputElement15.xml"/> |
| <suite.member href="HTMLInputElement16.xml"/> |
| <suite.member href="HTMLInputElement17.xml"/> |
| <suite.member href="HTMLInputElement18.xml"/> |
| <suite.member href="HTMLInputElement19.xml"/> |
| <suite.member href="HTMLInputElement20.xml"/> |
| <suite.member href="HTMLInputElement21.xml"/> |
| <suite.member href="HTMLInputElement22.xml"/> |
| <suite.member href="HTMLIsIndexElement01.xml"/> |
| <suite.member href="HTMLIsIndexElement02.xml"/> |
| <suite.member href="HTMLIsIndexElement03.xml"/> |
| <suite.member href="HTMLLabelElement01.xml"/> |
| <suite.member href="HTMLLabelElement02.xml"/> |
| <suite.member href="HTMLLabelElement03.xml"/> |
| <suite.member href="HTMLLabelElement04.xml"/> |
| <suite.member href="HTMLLegendElement01.xml"/> |
| <suite.member href="HTMLLegendElement02.xml"/> |
| <suite.member href="HTMLLegendElement03.xml"/> |
| <suite.member href="HTMLLegendElement04.xml"/> |
| <suite.member href="HTMLLIElement01.xml"/> |
| <suite.member href="HTMLLIElement02.xml"/> |
| <suite.member href="HTMLLinkElement01.xml"/> |
| <suite.member href="HTMLLinkElement02.xml"/> |
| <suite.member href="HTMLLinkElement03.xml"/> |
| <suite.member href="HTMLLinkElement04.xml"/> |
| <suite.member href="HTMLLinkElement05.xml"/> |
| <suite.member href="HTMLLinkElement06.xml"/> |
| <suite.member href="HTMLLinkElement07.xml"/> |
| <suite.member href="HTMLLinkElement08.xml"/> |
| <suite.member href="HTMLLinkElement09.xml"/> |
| <suite.member href="HTMLMapElement01.xml"/> |
| <suite.member href="HTMLMapElement02.xml"/> |
| <suite.member href="HTMLMenuElement01.xml"/> |
| <suite.member href="HTMLMetaElement01.xml"/> |
| <suite.member href="HTMLMetaElement02.xml"/> |
| <suite.member href="HTMLMetaElement03.xml"/> |
| <suite.member href="HTMLMetaElement04.xml"/> |
| <suite.member href="HTMLModElement01.xml"/> |
| <suite.member href="HTMLModElement02.xml"/> |
| <suite.member href="HTMLModElement03.xml"/> |
| <suite.member href="HTMLModElement04.xml"/> |
| <suite.member href="HTMLObjectElement01.xml"/> |
| <suite.member href="HTMLObjectElement02.xml"/> |
| <suite.member href="HTMLObjectElement03.xml"/> |
| <suite.member href="HTMLObjectElement04.xml"/> |
| <suite.member href="HTMLObjectElement05.xml"/> |
| <suite.member href="HTMLObjectElement06.xml"/> |
| <suite.member href="HTMLObjectElement07.xml"/> |
| <suite.member href="HTMLObjectElement08.xml"/> |
| <suite.member href="HTMLObjectElement09.xml"/> |
| <suite.member href="HTMLObjectElement10.xml"/> |
| <suite.member href="HTMLObjectElement11.xml"/> |
| <suite.member href="HTMLObjectElement12.xml"/> |
| <suite.member href="HTMLObjectElement13.xml"/> |
| <suite.member href="HTMLObjectElement14.xml"/> |
| <suite.member href="HTMLObjectElement15.xml"/> |
| <suite.member href="HTMLObjectElement16.xml"/> |
| <suite.member href="HTMLObjectElement17.xml"/> |
| <suite.member href="HTMLObjectElement18.xml"/> |
| <suite.member href="HTMLObjectElement19.xml"/> |
| <suite.member href="HTMLOListElement01.xml"/> |
| <suite.member href="HTMLOListElement02.xml"/> |
| <suite.member href="HTMLOListElement03.xml"/> |
| <suite.member href="HTMLOptGroupElement01.xml"/> |
| <suite.member href="HTMLOptGroupElement02.xml"/> |
| <suite.member href="HTMLOptionElement01.xml"/> |
| <suite.member href="HTMLOptionElement02.xml"/> |
| <suite.member href="HTMLOptionElement03.xml"/> |
| <suite.member href="HTMLOptionElement04.xml"/> |
| <suite.member href="HTMLOptionElement05.xml"/> |
| <suite.member href="HTMLOptionElement06.xml"/> |
| <suite.member href="HTMLOptionElement07.xml"/> |
| <suite.member href="HTMLOptionElement08.xml"/> |
| <suite.member href="HTMLOptionElement09.xml"/> |
| <suite.member href="HTMLParagraphElement01.xml"/> |
| <suite.member href="HTMLParamElement01.xml"/> |
| <suite.member href="HTMLParamElement02.xml"/> |
| <suite.member href="HTMLParamElement03.xml"/> |
| <suite.member href="HTMLParamElement04.xml"/> |
| <suite.member href="HTMLPreElement01.xml"/> |
| <suite.member href="HTMLQuoteElement01.xml"/> |
| <suite.member href="HTMLQuoteElement02.xml"/> |
| <suite.member href="HTMLScriptElement01.xml"/> |
| <suite.member href="HTMLScriptElement02.xml"/> |
| <suite.member href="HTMLScriptElement03.xml"/> |
| <suite.member href="HTMLScriptElement04.xml"/> |
| <suite.member href="HTMLScriptElement05.xml"/> |
| <suite.member href="HTMLScriptElement06.xml"/> |
| <suite.member href="HTMLScriptElement07.xml"/> |
| <suite.member href="HTMLSelectElement01.xml"/> |
| <suite.member href="HTMLSelectElement02.xml"/> |
| <suite.member href="HTMLSelectElement03.xml"/> |
| <suite.member href="HTMLSelectElement04.xml"/> |
| <suite.member href="HTMLSelectElement05.xml"/> |
| <suite.member href="HTMLSelectElement06.xml"/> |
| <suite.member href="HTMLSelectElement07.xml"/> |
| <suite.member href="HTMLSelectElement08.xml"/> |
| <suite.member href="HTMLSelectElement09.xml"/> |
| <suite.member href="HTMLSelectElement10.xml"/> |
| <suite.member href="HTMLSelectElement11.xml"/> |
| <suite.member href="HTMLSelectElement12.xml"/> |
| <suite.member href="HTMLSelectElement13.xml"/> |
| <suite.member href="HTMLSelectElement14.xml"/> |
| <suite.member href="HTMLSelectElement15.xml"/> |
| <suite.member href="HTMLSelectElement16.xml"/> |
| <suite.member href="HTMLSelectElement17.xml"/> |
| <suite.member href="HTMLSelectElement18.xml"/> |
| <suite.member href="HTMLSelectElement19.xml"/> |
| <suite.member href="HTMLStyleElement01.xml"/> |
| <suite.member href="HTMLStyleElement02.xml"/> |
| <suite.member href="HTMLStyleElement03.xml"/> |
| <suite.member href="HTMLTableCaptionElement01.xml"/> |
| <suite.member href="HTMLTableCellElement01.xml"/> |
| <suite.member href="HTMLTableCellElement02.xml"/> |
| <suite.member href="HTMLTableCellElement03.xml"/> |
| <suite.member href="HTMLTableCellElement04.xml"/> |
| <suite.member href="HTMLTableCellElement05.xml"/> |
| <suite.member href="HTMLTableCellElement06.xml"/> |
| <suite.member href="HTMLTableCellElement07.xml"/> |
| <suite.member href="HTMLTableCellElement08.xml"/> |
| <suite.member href="HTMLTableCellElement09.xml"/> |
| <suite.member href="HTMLTableCellElement10.xml"/> |
| <suite.member href="HTMLTableCellElement11.xml"/> |
| <suite.member href="HTMLTableCellElement12.xml"/> |
| <suite.member href="HTMLTableCellElement13.xml"/> |
| <suite.member href="HTMLTableCellElement14.xml"/> |
| <suite.member href="HTMLTableCellElement15.xml"/> |
| <suite.member href="HTMLTableCellElement16.xml"/> |
| <suite.member href="HTMLTableCellElement17.xml"/> |
| <suite.member href="HTMLTableCellElement18.xml"/> |
| <suite.member href="HTMLTableCellElement19.xml"/> |
| <suite.member href="HTMLTableCellElement20.xml"/> |
| <suite.member href="HTMLTableCellElement21.xml"/> |
| <suite.member href="HTMLTableCellElement22.xml"/> |
| <suite.member href="HTMLTableCellElement23.xml"/> |
| <suite.member href="HTMLTableCellElement24.xml"/> |
| <suite.member href="HTMLTableCellElement25.xml"/> |
| <suite.member href="HTMLTableCellElement26.xml"/> |
| <suite.member href="HTMLTableCellElement27.xml"/> |
| <suite.member href="HTMLTableCellElement28.xml"/> |
| <suite.member href="HTMLTableCellElement29.xml"/> |
| <suite.member href="HTMLTableCellElement30.xml"/> |
| <suite.member href="HTMLTableColElement01.xml"/> |
| <suite.member href="HTMLTableColElement02.xml"/> |
| <suite.member href="HTMLTableColElement03.xml"/> |
| <suite.member href="HTMLTableColElement04.xml"/> |
| <suite.member href="HTMLTableColElement05.xml"/> |
| <suite.member href="HTMLTableColElement06.xml"/> |
| <suite.member href="HTMLTableColElement07.xml"/> |
| <suite.member href="HTMLTableColElement08.xml"/> |
| <suite.member href="HTMLTableColElement09.xml"/> |
| <suite.member href="HTMLTableColElement10.xml"/> |
| <suite.member href="HTMLTableColElement11.xml"/> |
| <suite.member href="HTMLTableColElement12.xml"/> |
| <suite.member href="HTMLTableElement01.xml"/> |
| <suite.member href="HTMLTableElement02.xml"/> |
| <suite.member href="HTMLTableElement03.xml"/> |
| <suite.member href="HTMLTableElement04.xml"/> |
| <suite.member href="HTMLTableElement05.xml"/> |
| <suite.member href="HTMLTableElement06.xml"/> |
| <suite.member href="HTMLTableElement07.xml"/> |
| <suite.member href="HTMLTableElement08.xml"/> |
| <suite.member href="HTMLTableElement09.xml"/> |
| <suite.member href="HTMLTableElement10.xml"/> |
| <suite.member href="HTMLTableElement11.xml"/> |
| <suite.member href="HTMLTableElement12.xml"/> |
| <suite.member href="HTMLTableElement13.xml"/> |
| <suite.member href="HTMLTableElement14.xml"/> |
| <suite.member href="HTMLTableElement15.xml"/> |
| <suite.member href="HTMLTableElement16.xml"/> |
| <suite.member href="HTMLTableElement17.xml"/> |
| <suite.member href="HTMLTableElement18.xml"/> |
| <suite.member href="HTMLTableElement19.xml"/> |
| <suite.member href="HTMLTableElement20.xml"/> |
| <suite.member href="HTMLTableElement21.xml"/> |
| <suite.member href="HTMLTableElement22.xml"/> |
| <suite.member href="HTMLTableElement23.xml"/> |
| <suite.member href="HTMLTableElement24.xml"/> |
| <suite.member href="HTMLTableElement25.xml"/> |
| <suite.member href="HTMLTableElement26.xml"/> |
| <suite.member href="HTMLTableElement27.xml"/> |
| <suite.member href="HTMLTableElement28.xml"/> |
| <suite.member href="HTMLTableElement29.xml"/> |
| <suite.member href="HTMLTableElement30.xml"/> |
| <suite.member href="HTMLTableElement31.xml"/> |
| <suite.member href="HTMLTableElement32.xml"/> |
| <suite.member href="HTMLTableElement33.xml"/> |
| <suite.member href="HTMLTableRowElement01.xml"/> |
| <suite.member href="HTMLTableRowElement02.xml"/> |
| <suite.member href="HTMLTableRowElement03.xml"/> |
| <suite.member href="HTMLTableRowElement04.xml"/> |
| <suite.member href="HTMLTableRowElement05.xml"/> |
| <suite.member href="HTMLTableRowElement06.xml"/> |
| <suite.member href="HTMLTableRowElement07.xml"/> |
| <suite.member href="HTMLTableRowElement08.xml"/> |
| <suite.member href="HTMLTableRowElement09.xml"/> |
| <suite.member href="HTMLTableRowElement10.xml"/> |
| <suite.member href="HTMLTableRowElement11.xml"/> |
| <suite.member href="HTMLTableRowElement12.xml"/> |
| <suite.member href="HTMLTableRowElement13.xml"/> |
| <suite.member href="HTMLTableRowElement14.xml"/> |
| <suite.member href="HTMLTableSectionElement01.xml"/> |
| <suite.member href="HTMLTableSectionElement02.xml"/> |
| <suite.member href="HTMLTableSectionElement03.xml"/> |
| <suite.member href="HTMLTableSectionElement04.xml"/> |
| <suite.member href="HTMLTableSectionElement05.xml"/> |
| <suite.member href="HTMLTableSectionElement06.xml"/> |
| <suite.member href="HTMLTableSectionElement07.xml"/> |
| <suite.member href="HTMLTableSectionElement08.xml"/> |
| <suite.member href="HTMLTableSectionElement09.xml"/> |
| <suite.member href="HTMLTableSectionElement10.xml"/> |
| <suite.member href="HTMLTableSectionElement11.xml"/> |
| <suite.member href="HTMLTableSectionElement12.xml"/> |
| <suite.member href="HTMLTableSectionElement13.xml"/> |
| <suite.member href="HTMLTableSectionElement14.xml"/> |
| <suite.member href="HTMLTableSectionElement15.xml"/> |
| <suite.member href="HTMLTableSectionElement16.xml"/> |
| <suite.member href="HTMLTableSectionElement17.xml"/> |
| <suite.member href="HTMLTableSectionElement18.xml"/> |
| <suite.member href="HTMLTableSectionElement19.xml"/> |
| <suite.member href="HTMLTableSectionElement20.xml"/> |
| <suite.member href="HTMLTableSectionElement21.xml"/> |
| <suite.member href="HTMLTableSectionElement22.xml"/> |
| <suite.member href="HTMLTableSectionElement23.xml"/> |
| <suite.member href="HTMLTableSectionElement24.xml"/> |
| <suite.member href="HTMLTextAreaElement01.xml"/> |
| <suite.member href="HTMLTextAreaElement02.xml"/> |
| <suite.member href="HTMLTextAreaElement03.xml"/> |
| <suite.member href="HTMLTextAreaElement04.xml"/> |
| <suite.member href="HTMLTextAreaElement05.xml"/> |
| <suite.member href="HTMLTextAreaElement06.xml"/> |
| <suite.member href="HTMLTextAreaElement07.xml"/> |
| <suite.member href="HTMLTextAreaElement08.xml"/> |
| <suite.member href="HTMLTextAreaElement09.xml"/> |
| <suite.member href="HTMLTextAreaElement10.xml"/> |
| <suite.member href="HTMLTextAreaElement11.xml"/> |
| <suite.member href="HTMLTextAreaElement12.xml"/> |
| <suite.member href="HTMLTextAreaElement13.xml"/> |
| <suite.member href="HTMLTextAreaElement14.xml"/> |
| <suite.member href="HTMLTextAreaElement15.xml"/> |
| <suite.member href="HTMLTitleElement01.xml"/> |
| <suite.member href="HTMLUListElement01.xml"/> |
| <suite.member href="HTMLUListElement02.xml"/> |
| <!-- netscape tests --> |
| <suite.member href="anchor01.xml"/> |
| <suite.member href="anchor02.xml"/> |
| <suite.member href="anchor03.xml"/> |
| <suite.member href="anchor04.xml"/> |
| <suite.member href="anchor05.xml"/> |
| <suite.member href="anchor06.xml"/> |
| <suite.member href="area01.xml"/> |
| <suite.member href="area02.xml"/> |
| <suite.member href="area03.xml"/> |
| <suite.member href="area04.xml"/> |
| <suite.member href="basefont01.xml"/> |
| <suite.member href="body01.xml"/> |
| <suite.member href="button01.xml"/> |
| <suite.member href="button02.xml"/> |
| <suite.member href="button03.xml"/> |
| <suite.member href="button04.xml"/> |
| <suite.member href="button05.xml"/> |
| <suite.member href="button06.xml"/> |
| <suite.member href="button07.xml"/> |
| <suite.member href="button08.xml"/> |
| <suite.member href="button09.xml"/> |
| <suite.member href="dlist01.xml"/> |
| <suite.member href="doc01.xml"/> |
| <suite.member href="hasFeature01.xml"/> |
| <suite.member href="object01.xml"/> |
| <suite.member href="object02.xml"/> |
| <suite.member href="object03.xml"/> |
| <suite.member href="object04.xml"/> |
| <suite.member href="object05.xml"/> |
| <suite.member href="object06.xml"/> |
| <suite.member href="object07.xml"/> |
| <suite.member href="object08.xml"/> |
| <suite.member href="object09.xml"/> |
| <suite.member href="object10.xml"/> |
| <suite.member href="object11.xml"/> |
| <suite.member href="object12.xml"/> |
| <suite.member href="object13.xml"/> |
| <suite.member href="object14.xml"/> |
| <suite.member href="object15.xml"/> |
| <suite.member href="table01.xml"/> |
| <suite.member href="table02.xml"/> |
| <suite.member href="table03.xml"/> |
| <suite.member href="table04.xml"/> |
| <suite.member href="table06.xml"/> |
| <suite.member href="table07.xml"/> |
| <suite.member href="table08.xml"/> |
| <suite.member href="table09.xml"/> |
| <suite.member href="table10.xml"/> |
| <suite.member href="table12.xml"/> |
| <suite.member href="table15.xml"/> |
| <suite.member href="table17.xml"/> |
| <suite.member href="table18.xml"/> |
| <suite.member href="table19.xml"/> |
| <suite.member href="table20.xml"/> |
| <suite.member href="table21.xml"/> |
| <suite.member href="table22.xml"/> |
| <suite.member href="table23.xml"/> |
| <suite.member href="table24.xml"/> |
| <suite.member href="table25.xml"/> |
| <suite.member href="table26.xml"/> |
| <suite.member href="table27.xml"/> |
| <suite.member href="table28.xml"/> |
| <suite.member href="table29.xml"/> |
| <suite.member href="table30.xml"/> |
| <suite.member href="table31.xml"/> |
| <suite.member href="table32.xml"/> |
| <suite.member href="table33.xml"/> |
| <suite.member href="table34.xml"/> |
| <suite.member href="table35.xml"/> |
| <suite.member href="table36.xml"/> |
| <suite.member href="table37.xml"/> |
| <suite.member href="table38.xml"/> |
| <suite.member href="table39.xml"/> |
| <suite.member href="table40.xml"/> |
| <suite.member href="table41.xml"/> |
| <suite.member href="table42.xml"/> |
| <suite.member href="table43.xml"/> |
| <suite.member href="table44.xml"/> |
| <suite.member href="table45.xml"/> |
| <suite.member href="table46.xml"/> |
| <suite.member href="table47.xml"/> |
| <suite.member href="table48.xml"/> |
| <suite.member href="table49.xml"/> |
| <suite.member href="table50.xml"/> |
| <suite.member href="table51.xml"/> |
| <suite.member href="table52.xml"/> |
| <suite.member href="table53.xml"/> |
| </suite> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/anchor01.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="anchor01"> |
| <metadata> |
| <title>anchor01</title> |
| <creator>Netscape</creator> |
| <description> |
| A single character access key to give access to the form control. |
| The value of attribute accessKey of the anchor element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-89647724"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaccesskey" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <accessKey interface="HTMLAnchorElement" obj="testNode" var="vaccesskey"/> |
| <assertEquals actual="vaccesskey" expected='"g"' id="accessKeyLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/anchor02.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="anchor02"> |
| <metadata> |
| <title>anchor02</title> |
| <creator>Netscape</creator> |
| <description> |
| The character encoding of the linked resource. |
| The value of attribute charset of the anchor element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-67619266"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcharset" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <charset interface="HTMLAnchorElement" obj="testNode" var="vcharset"/> |
| <assertEquals actual="vcharset" expected='"US-ASCII"' id="charsetLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/anchor03.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="anchor03"> |
| <metadata> |
| <title>anchor03</title> |
| <creator>Netscape</creator> |
| <description> |
| Comma-separated list of lengths, defining an active region geometry. |
| The value of attribute coords of the anchor element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-92079539"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcoords" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <coords interface="HTMLAnchorElement" obj="testNode" var="vcoords"/> |
| <assertEquals actual="vcoords" expected='"0,0,100,100"' id="coordsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/anchor04.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="anchor04"> |
| <metadata> |
| <title>anchor04</title> |
| <creator>Netscape</creator> |
| <description> |
| The URI of the linked resource. |
| The value of attribute href of the anchor element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88517319"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhref" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <href interface="HTMLAnchorElement" obj="testNode" var="vhref"/> |
| <assertURIEquals actual="vhref" isAbsolute="true" file='"submit.gif"' id="hrefLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/anchor05.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="anchor05"> |
| <metadata> |
| <title>anchor05</title> |
| <creator>Netscape</creator> |
| <description> |
| Advisory content type. |
| The value of attribute type of the anchor element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63938221"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLAnchorElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"image/gif"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/anchor06.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="anchor06"> |
| <metadata> |
| <title>anchor06</title> |
| <creator>Netscape</creator> |
| <description> |
| The shape of the active area. The coordinates are given by coords |
| The value of attribute shape of the anchor element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-02</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-49899808"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vshape" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"a"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <shape interface="HTMLAnchorElement" obj="testNode" var="vshape"/> |
| <assertEquals actual="vshape" expected='"rect"' id="shapeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/area01.xml.notimpl |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="area01"> |
| <metadata> |
| <title>area01</title> |
| <creator>Netscape</creator> |
| <description> |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-66021476"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcoords" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <coords interface="HTMLAreaElement" obj="testNode" var="vcoords"/> |
| <assertEquals actual="vcoords" expected='"0,2,45,45"' id="coordsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/area02.xml.notimpl |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="area02"> |
| <metadata> |
| <title>area02</title> |
| <creator>Netscape</creator> |
| <description> |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-61826871"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vnohref" type="boolean" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <noHref interface="HTMLAreaElement" obj="testNode" var="vnohref"/> |
| <assertFalse actual="vnohref" id="noHrefLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/area03.xml.notimpl |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="area03"> |
| <metadata> |
| <title>area03</title> |
| <creator>Netscape</creator> |
| <description> |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-8722121"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtabindex" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tabIndex interface="HTMLAreaElement" obj="testNode" var="vtabindex"/> |
| <assertEquals actual="vtabindex" expected="10" id="tabIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/area04.xml.notimpl |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="area04"> |
| <metadata> |
| <title>area04</title> |
| <creator>Netscape</creator> |
| <description> |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-57944457"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaccesskey" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="area" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"area"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <accessKey interface="HTMLAreaElement" obj="testNode" var="vaccesskey"/> |
| <assertEquals actual="vaccesskey" expected='"a"' id="accessKeyLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/basefont01.xml.notimpl |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="basefont01"> |
| <metadata> |
| <title>basefont01</title> |
| <creator>Netscape</creator> |
| <description> |
| The value of attribute color of the basefont element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87502302"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcolor" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="basefont" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"basefont"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <color interface="HTMLBaseFontElement" obj="testNode" var="vcolor"/> |
| <assertEquals actual="vcolor" expected='"#000000"' id="colorLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/body01.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="body01"> |
| <metadata> |
| <title>body01</title> |
| <creator>Netscape</creator> |
| <description> |
| Color of active links (after mouse-button down, but before mouse-button up). |
| The value of attribute alink of the body element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59424581"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valink" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="body" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"body"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <aLink interface="HTMLBodyElement" obj="testNode" var="valink"/> |
| <assertEquals actual="valink" expected='"#0000ff"' id="aLinkLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/button01.xml.notimpl |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="button01"> |
| <metadata> |
| <title>button01</title> |
| <creator>Netscape</creator> |
| <description> |
| Returns the FORM element containing this control. Returns null if this control is not within the context of a form. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-71254493"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="Node"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <form interface="HTMLButtonElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/button02.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="button02"> |
| <metadata> |
| <title>button02</title> |
| <creator>Netscape</creator> |
| <description> |
| The value of attribute name of the form element which contains this button is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-71254493"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-63534901"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="formNode" type="Node"/> |
| <var name="vfname" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLButtonElement" obj="testNode" var="formNode"/> |
| <id interface="HTMLElement" obj="formNode" var="vfname"/> |
| <assertEquals actual="vfname" expected='"form2"' id="formLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/button03.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="button03"> |
| <metadata> |
| <title>button03</title> |
| <creator>Netscape</creator> |
| <description> |
| The value of attribute action of the form element which contains this button is read and checked against the expected value |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-71254493"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-74049184"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="formNode" type="Node"/> |
| <var name="vfaction" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLButtonElement" obj="testNode" var="formNode"/> |
| <action interface="HTMLFormElement" obj="formNode" var="vfaction"/> |
| <assertEquals actual="vfaction" expected='"..."' id="formLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/button04.xml.notimpl |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="button04"> |
| <metadata> |
| <title>button04</title> |
| <creator>Netscape</creator> |
| <description> |
| The value of attribute method of the form element which contains this button is read and checked against the expected value |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-71254493"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-82545539"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="formNode" type="Node"/> |
| <var name="vfmethod" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLButtonElement" obj="testNode" var="formNode"/> |
| <method interface="HTMLFormElement" obj="formNode" var="vfmethod"/> |
| <assertEquals actual="vfmethod" expected='"POST"' id="formLink" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/button05.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="button05"> |
| <metadata> |
| <title>button05</title> |
| <creator>Netscape</creator> |
| <description> |
| A single character access key to give access to the form control. |
| The value of attribute accessKey of the button element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-73169431"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vakey" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <accessKey interface="HTMLButtonElement" obj="testNode" var="vakey"/> |
| <assertEquals actual="vakey" expected='"f"' id="accessKeyLink" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/button06.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="button06"> |
| <metadata> |
| <title>button06</title> |
| <creator>Netscape</creator> |
| <description> |
| Index that represents the element's position in the tabbing order. |
| The value of attribute tabIndex of the button element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-39190908"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtabIndex" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tabIndex interface="HTMLButtonElement" obj="testNode" var="vtabIndex"/> |
| <assertEquals actual="vtabIndex" expected="20" id="tabIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/button07.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="button07"> |
| <metadata> |
| <title>button07</title> |
| <creator>Netscape</creator> |
| <description> |
| The type of button |
| The value of attribute type of the button element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-27430092"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLButtonElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"reset"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/button08.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="button08"> |
| <metadata> |
| <title>button08</title> |
| <creator>Netscape</creator> |
| <description> |
| The control is unavailable in this context. |
| The boolean value of attribute disabled of the button element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-92757155"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdisabled" type="boolean" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <disabled interface="HTMLButtonElement" obj="testNode" var="vdisabled"/> |
| <assertTrue actual="vdisabled" id="disabledLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/button09.xml.notimpl |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="button09"> |
| <metadata> |
| <title>button09</title> |
| <creator>Netscape</creator> |
| <description> |
| The current form control value. |
| The value of attribute value of the button element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-03-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-72856782"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalue" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="button" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"button"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <value interface="HTMLButtonElement" obj="testNode" var="vvalue"/> |
| <assertEquals actual="vvalue" expected='"Reset Disabled Button"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/dlist01.xml.notimpl |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="dlist01"> |
| <metadata> |
| <title>dlist01</title> |
| <creator>Netscape</creator> |
| <description> |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-21738539"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcompact" type="boolean" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="dl" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"dl"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <compact interface="HTMLDListElement" obj="testNode" var="vcompact"/> |
| <assertTrue actual="vcompact" id="compactLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/doc01.xml.notimpl |
|---|
| 0,0 → 1,34 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="doc01"> |
| <metadata> |
| <title>doc01</title> |
| <creator>Netscape</creator> |
| <description> |
| Retrieve the title attribute of HTMLDocument and examine it's value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-08</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-18446827"/> |
| </metadata> |
| <var name="vtitle" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="anchor" willBeModified="false"/> |
| <title interface="HTMLDocument" obj="doc" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"NIST DOM HTML Test - Anchor"' id="titleLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/.cvsignore |
|---|
| 0,0 → 1,6 |
| xhtml1-frameset.dtd |
| xhtml1-strict.dtd |
| xhtml1-transitional.dtd |
| xhtml-lat1.ent |
| xhtml-special.ent |
| xhtml-symbol.ent |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/CVS/Entries |
|---|
| 0,0 → 1,196 |
| /.cvsignore/1.1/Fri Apr 3 02:48:01 2009// |
| /anchor.html/1.3/Fri Apr 3 02:48:01 2009// |
| /anchor.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /anchor.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /anchor2.html/1.2/Fri Apr 3 02:48:01 2009// |
| /anchor2.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /anchor2.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /applet.html/1.5/Fri Apr 3 02:48:01 2009// |
| /applet.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /applet.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /applet2.html/1.3/Fri Apr 3 02:48:01 2009// |
| /applet2.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /applet2.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /area.html/1.3/Fri Apr 3 02:48:01 2009// |
| /area.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /area.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /area2.html/1.3/Fri Apr 3 02:48:01 2009// |
| /area2.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /area2.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /base.html/1.4/Fri Apr 3 02:48:01 2009// |
| /base.xhtml/1.3/Fri Apr 3 02:48:01 2009/-kb/ |
| /base.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /base2.html/1.4/Fri Apr 3 02:48:01 2009// |
| /base2.xhtml/1.4/Fri Apr 3 02:48:01 2009/-kb/ |
| /base2.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /basefont.html/1.3/Fri Apr 3 02:48:01 2009// |
| /basefont.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /basefont.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /body.html/1.3/Fri Apr 3 02:48:01 2009// |
| /body.xhtml/1.3/Fri Apr 3 02:48:01 2009/-kb/ |
| /body.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /br.html/1.3/Fri Apr 3 02:48:01 2009// |
| /br.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /br.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /button.html/1.4/Fri Apr 3 02:48:01 2009// |
| /button.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /button.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /collection.html/1.3/Fri Apr 3 02:48:01 2009// |
| /collection.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /collection.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /directory.html/1.3/Fri Apr 3 02:48:01 2009// |
| /directory.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /directory.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /div.html/1.3/Fri Apr 3 02:48:01 2009// |
| /div.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /div.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /dl.html/1.3/Fri Apr 3 02:48:01 2009// |
| /dl.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /dl.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /document.html/1.5/Fri Apr 3 02:48:01 2009// |
| /document.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /document.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /element.html/1.3/Fri Apr 3 02:48:01 2009// |
| /element.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /element.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /fieldset.html/1.4/Fri Apr 3 02:48:01 2009// |
| /fieldset.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /fieldset.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /font.html/1.3/Fri Apr 3 02:48:01 2009// |
| /font.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /font.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /form.html/1.3/Fri Apr 3 02:48:01 2009// |
| /form.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /form.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /form2.html/1.2/Fri Apr 3 02:48:01 2009// |
| /form2.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /form2.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /form3.html/1.1/Fri Apr 3 02:48:01 2009// |
| /form3.xhtml/1.1/Fri Apr 3 02:48:01 2009/-kb/ |
| /form3.xml/1.1/Fri Apr 3 02:48:01 2009// |
| /frame.html/1.3/Fri Apr 3 02:48:01 2009// |
| /frame.xhtml/1.3/Fri Apr 3 02:48:01 2009/-kb/ |
| /frame.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /frameset.html/1.2/Fri Apr 3 02:48:01 2009// |
| /frameset.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /frameset.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /head.html/1.4/Fri Apr 3 02:48:01 2009// |
| /head.xhtml/1.3/Fri Apr 3 02:48:01 2009/-kb/ |
| /head.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /heading.html/1.3/Fri Apr 3 02:48:01 2009// |
| /heading.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /heading.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /hr.html/1.3/Fri Apr 3 02:48:01 2009// |
| /hr.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /hr.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /html.html/1.4/Fri Apr 3 02:48:01 2009// |
| /html.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /html.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /iframe.html/1.4/Fri Apr 3 02:48:01 2009// |
| /iframe.xhtml/1.3/Fri Apr 3 02:48:01 2009/-kb/ |
| /iframe.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /img.html/1.3/Fri Apr 3 02:48:01 2009// |
| /img.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /img.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /input.html/1.5/Fri Apr 3 02:48:01 2009// |
| /input.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /input.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /isindex.html/1.4/Fri Apr 3 02:48:01 2009// |
| /isindex.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /isindex.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /label.html/1.3/Fri Apr 3 02:48:01 2009// |
| /label.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /label.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /legend.html/1.4/Fri Apr 3 02:48:01 2009// |
| /legend.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /legend.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /li.html/1.3/Fri Apr 3 02:48:01 2009// |
| /li.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /li.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /link.html/1.4/Fri Apr 3 02:48:01 2009// |
| /link.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /link.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /link2.html/1.2/Fri Apr 3 02:48:01 2009// |
| /link2.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /link2.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /map.html/1.3/Fri Apr 3 02:48:01 2009// |
| /map.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /map.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /menu.html/1.3/Fri Apr 3 02:48:01 2009// |
| /menu.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /menu.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /meta.html/1.2/Fri Apr 3 02:48:01 2009// |
| /meta.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /meta.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /mod.html/1.2/Fri Apr 3 02:48:01 2009// |
| /mod.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /mod.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /object.html/1.5/Fri Apr 3 02:48:01 2009// |
| /object.xhtml/1.3/Fri Apr 3 02:48:01 2009/-kb/ |
| /object.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /object2.html/1.3/Fri Apr 3 02:48:01 2009// |
| /object2.xhtml/1.3/Fri Apr 3 02:48:01 2009/-kb/ |
| /object2.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /olist.html/1.3/Fri Apr 3 02:48:01 2009// |
| /olist.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /olist.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /optgroup.html/1.2/Fri Apr 3 02:48:01 2009// |
| /optgroup.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /optgroup.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /option.html/1.3/Fri Apr 3 02:48:01 2009// |
| /option.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /option.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /paragraph.html/1.3/Fri Apr 3 02:48:01 2009// |
| /paragraph.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /paragraph.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /param.html/1.2/Fri Apr 3 02:48:01 2009// |
| /param.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /param.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /pre.html/1.3/Fri Apr 3 02:48:01 2009// |
| /pre.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /pre.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /quote.html/1.2/Fri Apr 3 02:48:01 2009// |
| /quote.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /quote.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /right.png/1.1/Fri Apr 3 02:48:01 2009/-kb/ |
| /script.html/1.3/Fri Apr 3 02:48:01 2009// |
| /script.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /script.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /select.html/1.4/Fri Apr 3 02:48:01 2009// |
| /select.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /select.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /style.html/1.3/Fri Apr 3 02:48:01 2009// |
| /style.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /style.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /table.html/1.3/Fri Apr 3 02:48:01 2009// |
| /table.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /table.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /table1.html/1.4/Fri Apr 3 02:48:01 2009// |
| /table1.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /table1.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /tablecaption.html/1.3/Fri Apr 3 02:48:01 2009// |
| /tablecaption.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /tablecaption.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /tablecell.html/1.3/Fri Apr 3 02:48:01 2009// |
| /tablecell.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /tablecell.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /tablecol.html/1.3/Fri Apr 3 02:48:01 2009// |
| /tablecol.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /tablecol.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /tablerow.html/1.3/Fri Apr 3 02:48:01 2009// |
| /tablerow.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /tablerow.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /tablesection.html/1.4/Fri Apr 3 02:48:01 2009// |
| /tablesection.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /tablesection.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /textarea.html/1.4/Fri Apr 3 02:48:01 2009// |
| /textarea.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /textarea.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /title.html/1.3/Fri Apr 3 02:48:01 2009// |
| /title.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /title.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /ulist.html/1.3/Fri Apr 3 02:48:01 2009// |
| /ulist.xhtml/1.2/Fri Apr 3 02:48:01 2009/-kb/ |
| /ulist.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /w3c_main.png/1.1/Fri Apr 3 02:48:01 2009/-kb/ |
| D |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level1/html/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/CVS/Template |
|---|
| --- test/testcases/tests/level1/html/files/anchor.html (nonexistent) |
| +++ test/testcases/tests/level1/html/files/anchor.html (revision 4364) |
| @@ -0,0 +1,12 @@ |
| +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| +<HTML> |
| +<HEAD> |
| +<META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| +<TITLE>NIST DOM HTML Test - Anchor</TITLE> |
| +</HEAD> |
| +<BODY onload="parent.loadComplete()"> |
| +<P> |
| +<A ID="Anchor" DIR="LTR" HREF="./pix/submit.gif" ACCESSKEY="g" TYPE="image/gif" COORDS="0,0,100,100" SHAPE="rect" REL="GLOSSARY" REV="STYLESHEET" HREFLANG="en" CHARSET="US-ASCII" TABINDEX="22" NAME="Anchor">View Submit Button</A> |
| +</P> |
| +</BODY> |
| +</HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/anchor.xhtml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Anchor</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <a id="Anchor" dir="ltr" href="./pix/submit.gif" accesskey="g" type="image/gif" coords="0,0,100,100" shape="rect" rel="GLOSSARY" rev="STYLESHEET" hreflang="en" charset="US-ASCII" tabindex="22" name="Anchor">View Submit Button</a> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/anchor.xml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Anchor</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <a id="Anchor" dir="ltr" href="./pix/submit.gif" accesskey="g" type="image/gif" coords="0,0,100,100" shape="rect" rel="GLOSSARY" rev="STYLESHEET" hreflang="en" charset="US-ASCII" tabindex="22" name="Anchor">View Submit Button</a> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/anchor2.html |
|---|
| 0,0 → 1,13 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" |
| "http://www.w3.org/TR/html4/loose.dtd"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Anchor</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <A HREF="./pix/submit.gif" TARGET="dynamic">View Submit Button</A> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/anchor2.xhtml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Anchor</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <a href="./pix/submit.gif" target="dynamic">View Submit Button</a> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/anchor2.xml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Anchor</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <a href="./pix/submit.gif" target="dynamic">View Submit Button</a> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/applet.html |
|---|
| 0,0 → 1,12 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Applet</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <APPLET ALIGN="bottom" ALT="Applet Number 1" ARCHIVE="" CODE="org/w3c/domts/DOMTSApplet.class" CODEBASE="applets" HEIGHT="306" HSPACE="0" NAME="applet1" VSPACE="0" WIDTH="301"></APPLET> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/applet.xhtml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Applet</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <applet align="bottom" alt="Applet Number 1" archive="" code="org/w3c/domts/DOMTSApplet.class" codebase="applets" height="306" hspace="0" name="applet1" vspace="0" width="301"></applet> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/applet.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Applet</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <applet align="bottom" alt="Applet Number 1" archive="" code="org/w3c/domts/DOMTSApplet.class" codebase="applets" height="306" hspace="0" name="applet1" vspace="0" width="301"></applet> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/applet2.html |
|---|
| 0,0 → 1,12 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Applet</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <APPLET ALIGN="bottom" ALT="Applet Number 1" ARCHIVE="" OBJECT="DOMTSApplet.dat" CODEBASE="applets" HEIGHT="306" HSPACE="0" NAME="applet1" VSPACE="0" WIDTH="301"></APPLET> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/applet2.xhtml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Applet</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <applet align="bottom" alt="Applet Number 1" archive="" object="DOMTSApplet.dat" codebase="applets" height="306" hspace="0" name="applet1" vspace="0" width="301"></applet> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/applet2.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Applet</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <applet align="bottom" alt="Applet Number 1" archive="" object="DOMTSApplet.dat" codebase="applets" height="306" hspace="0" name="applet1" vspace="0" width="301"></applet> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/area.html |
|---|
| 0,0 → 1,14 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Area</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <MAP NAME="mapid" ID="mapid"> |
| <AREA TABINDEX="10" ACCESSKEY="a" SHAPE="rect" ALT="Domain" COORDS="0,2,45,45" HREF="./files/dletter.html" TITLE="Domain"> |
| </MAP> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/area.xhtml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Area</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <map name="mapid" id="mapid"> |
| <area tabindex="10" accesskey="a" shape="rect" alt="Domain" coords="0,2,45,45" href="./files/dletter.html" title="Domain"/> |
| </map> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/area.xml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Area</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <map name="mapid" id="mapid"> |
| <area tabindex="10" accesskey="a" shape="rect" alt="Domain" coords="0,2,45,45" href="./files/dletter.html" title="Domain"/> |
| </map> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/area2.html |
|---|
| 0,0 → 1,15 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" |
| "http://www.w3.org/TR/html4/loose.dtd"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Area</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <MAP NAME="mapid" ID="mapid"> |
| <AREA HREF="./files/dletter.html" ALT="Domain" TARGET="dynamic"> |
| </MAP> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/area2.xhtml |
|---|
| 0,0 → 1,16 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Area</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <map name="mapid" id="mapid"> |
| <area href="./files/dletter.html" alt="Domain" target="dynamic"/> |
| </map> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/area2.xml |
|---|
| 0,0 → 1,16 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Area</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <map name="mapid" id="mapid"> |
| <area href="./files/dletter.html" alt="Domain" target="dynamic"/> |
| </map> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/base.html |
|---|
| 0,0 → 1,11 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <BASE HREF="about:blank"> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Base</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P>Some Text</P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/base.xhtml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <base href="about:blank"/> |
| <title>NIST DOM HTML Test - Base</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>Some Text</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/base.xml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <base href="about:blank"/> |
| <title>NIST DOM HTML Test - Base</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>Some Text</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/base2.html |
|---|
| 0,0 → 1,15 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" |
| "http://www.w3.org/TR/html4/frameset.dtd"> |
| <HTML> |
| <HEAD> |
| <BASE HREF="about:blank" TARGET="Frame1"> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Base2</TITLE> |
| </HEAD> |
| <FRAMESET COLS="20, 80" onload="parent.loadComplete()"> |
| <FRAMESET ROWS="100, 200"> |
| <FRAME MARGINHEIGHT="10" MARGINWIDTH="5" NORESIZE="NORESIZE" NAME="Frame1" FRAMEBORDER="1" SCROLLING="yes"> |
| </FRAMESET> |
| <FRAME> |
| </FRAMESET> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/base2.xhtml |
|---|
| 0,0 → 1,16 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" |
| "xhtml1-frameset.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <base href="about:blank" target="Frame1"/> |
| <title>NIST DOM HTML Test - Base2</title> |
| </head> |
| <frameset cols="20, 80" onload="parent.loadComplete()"> |
| <frameset rows="100, 200"> |
| <frame marginheight="10" marginwidth="5" noresize="noresize" name="Frame1" frameborder="1" scrolling="yes" /> |
| </frameset> |
| <frame /> |
| </frameset> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/base2.xml |
|---|
| 0,0 → 1,16 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" |
| "xhtml1-frameset.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <base href="about:blank" target="Frame1"/> |
| <title>NIST DOM HTML Test - Base2</title> |
| </head> |
| <frameset cols="20, 80" onload="parent.loadComplete()"> |
| <frameset rows="100, 200"> |
| <frame marginheight="10" marginwidth="5" noresize="noresize" name="Frame1" frameborder="1" scrolling="yes" /> |
| </frameset> |
| <frame /> |
| </frameset> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/basefont.html |
|---|
| 0,0 → 1,12 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - BaseFont</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <BASEFONT COLOR="#000000" FACE="arial,helvitica" SIZE="4"> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/basefont.xhtml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - BaseFont</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <basefont color="#000000" face="arial,helvitica" size="4"/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/basefont.xml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - BaseFont</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <basefont color="#000000" face="arial,helvitica" size="4"/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/body.html |
|---|
| 0,0 → 1,10 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Body</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()" ALINK="#0000ff" BACKGROUND="./pix/back1.gif" BGCOLOR="#ffff00" LINK="#ff0000" TEXT="#000000" VLINK="#00ffff"> |
| <P>Hello, World</P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/body.xhtml |
|---|
| 0,0 → 1,12 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Body</title> |
| </head> |
| <body onload="parent.loadComplete()" alink="#0000ff" background="./pix/back1.gif" bgcolor="#ffff00" link="#ff0000" text="#000000" vlink="#00ffff"> |
| <p>Hello, World.</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/body.xml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <base href="http://xw2k.sdct.itl.nist.gov/brady/dom/"/> |
| <title>NIST DOM HTML Test - Body</title> |
| </head> |
| <body onload="parent.loadComplete()" alink="#0000ff" background="./pix/back1.gif" bgcolor="#ffff00" link="#ff0000" text="#000000" vlink="#00ffff"> |
| <p>Hello, World.</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/br.html |
|---|
| 0,0 → 1,12 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - BR</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <BR CLEAR="none"> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/br.xhtml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - BR</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <br clear="none"/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/br.xml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - BR</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <br clear="none"/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/button.html |
|---|
| 0,0 → 1,21 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Button</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form2" ACTION="..." METHOD="POST"> |
| <P> |
| <BUTTON ACCESSKEY="f" NAME="disabledButton" TABINDEX="20" TYPE="reset" VALUE="Reset Disabled Button" DISABLED="disabled">Reset</BUTTON> |
| </P> |
| </FORM> |
| <TABLE SUMMARY="Extra Button Table"> |
| <TR> |
| <TD> |
| <BUTTON>Extra Button</BUTTON> |
| </TD> |
| </TR> |
| </TABLE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/button.xhtml |
|---|
| 0,0 → 1,24 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Button</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form2" action="..." method="post"> |
| <p> |
| <button accesskey="f" name="disabledButton" tabindex="20" type="reset" value="Reset Disabled Button" disabled="disabled">Reset</button> |
| </p> |
| </form> |
| <table summary="Extra Button Table"> |
| <tr> |
| <td> |
| <button>Extra Button</button> |
| </td> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/button.xml |
|---|
| 0,0 → 1,24 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Button</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form2" action="..." method="post"> |
| <p> |
| <button accesskey="f" name="disabledButton" tabindex="20" type="reset" value="Reset Disabled Button" disabled="disabled">Reset</button> |
| </p> |
| </form> |
| <table summary="Extra Button Table"> |
| <tr> |
| <td> |
| <button>Extra Button</button> |
| </td> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/collection.html |
|---|
| 0,0 → 1,79 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - SELECT</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <TABLE ID="table-1" BORDER="4" FRAME="border" CELLPADDING="2" CELLSPACING="2" SUMMARY="HTML Control Table" RULES="all"> |
| <CAPTION>Table Caption</CAPTION> |
| <THEAD ALIGN="center" VALIGN="middle"> |
| <TR ALIGN="center" VALIGN="middle" CHAR="*" CHAROFF="1"> |
| <TH ID="header-1">Employee Id</TH> |
| <TH ID="header-2" ABBR="maiden" AXIS="center" ALIGN="center" COLSPAN="1" ROWSPAN="1" SCOPE="col" HEADERS="header-1" VALIGN="middle">Employee Name</TH> |
| <TH>Position</TH> |
| <TH>Salary</TH> |
| <TH>Gender</TH> |
| <TH>Address</TH> |
| </TR> |
| </THEAD> |
| <TFOOT ALIGN="center" VALIGN="middle"> |
| <TR> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| </TR> |
| </TFOOT> |
| <TBODY ALIGN="center" VALIGN="middle"> |
| <TR> |
| <TD AXIS="center" ID="Table-3" ABBR="maiden2" COLSPAN="1" ROWSPAN="1" SCOPE="col" HEADERS="header-2" VALIGN="middle">EMP0001</TD> |
| <TD HEADERS="header-2">Margaret Martin</TD> |
| <TD>Accountant</TD> |
| <TD>56,000</TD> |
| <TD>Female</TD> |
| <TD>1230 North Ave. Dallas, Texas 98551</TD> |
| </TR> |
| <TR> |
| <TD>EMP0002</TD> |
| <TD>Martha Raynolds</TD> |
| <TD>Secretary</TD> |
| <TD>35,000</TD> |
| <TD>Female</TD> |
| <TD>1900 Dallas Road Dallas, Texas 98554</TD> |
| </TR> |
| </TBODY> |
| </TABLE> |
| <FORM ID="form1" ACTION="./files/getData.pl" METHOD="post"> |
| <P> |
| <SELECT ID="selectId" DIR="ltr" TABINDEX="7" NAME="select1" MULTIPLE="multiple" SIZE="1"> |
| <OPTION SELECTED="selected" value="EMP1">EMP10001</OPTION> |
| <OPTION>EMP10002</OPTION> |
| <OPTION>EMP10003</OPTION> |
| <OPTION>EMP10004</OPTION> |
| <OPTION>EMP10005</OPTION> |
| </SELECT> |
| </P> |
| </FORM> |
| <P> |
| <SELECT NAME="select2"> |
| <OPTION>EMP20001</OPTION> |
| <OPTION>EMP20002</OPTION> |
| <OPTION>EMP20003</OPTION> |
| <OPTION>EMP20004</OPTION> |
| <OPTION>EMP20005</OPTION> |
| </SELECT> |
| </P> |
| <P> |
| <SELECT NAME="select3" DISABLED="disabled" TABINDEX="1"> |
| <OPTION>EMP30001</OPTION> |
| <OPTION>EMP30002</OPTION> |
| <OPTION>EMP30003</OPTION> |
| <OPTION>EMP30004</OPTION> |
| <OPTION>EMP30005</OPTION> |
| </SELECT> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/collection.xhtml |
|---|
| 0,0 → 1,82 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - BR</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table id="table-1" border="4" frame="border" cellpadding="2" cellspacing="2" summary="HTML Control Table" rules="all"> |
| <caption>Table Caption</caption> |
| <thead align="center" valign="middle"> |
| <tr align="center" valign="middle" char="*" charoff="1"> |
| <th id="header-1">Employee Id</th> |
| <th id="header-2" abbr="maiden" axis="center" align="center" colspan="1" rowspan="1" scope="col" headers="header-1" valign="middle">Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| <th>Gender</th> |
| <th>Address</th> |
| </tr> |
| </thead> |
| <tfoot align="center" valign="middle"> |
| <tr> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| </tr> |
| </tfoot> |
| <tbody align="center" valign="middle"> |
| <tr> |
| <td axis="center" id="Table-3" abbr="maiden2" colspan="1" rowspan="1" scope="col" headers="header-2" valign="middle">EMP0001</td> |
| <td headers="header-2">Margaret Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| <td>Female</td> |
| <td>1230 North Ave. Dallas, Texas 98551</td> |
| </tr> |
| <tr> |
| <td>EMP0002</td> |
| <td>Martha Raynolds</td> |
| <td>Secretary</td> |
| <td>35,000</td> |
| <td>Female</td> |
| <td>1900 Dallas Road Dallas, Texas 98554</td> |
| </tr> |
| </tbody> |
| </table> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <select id="selectId" dir="ltr" tabindex="7" name="select1" multiple="multiple" size="1"> |
| <option selected="selected" value="EMP1">EMP10001</option> |
| <option>EMP10002</option> |
| <option>EMP10003</option> |
| <option>EMP10004</option> |
| <option>EMP10005</option> |
| </select> |
| </p> |
| </form> |
| <p> |
| <select name="select2"> |
| <option>EMP20001</option> |
| <option>EMP20002</option> |
| <option>EMP20003</option> |
| <option>EMP20004</option> |
| <option>EMP20005</option> |
| </select> |
| </p> |
| <p> |
| <select name="select3" disabled="disabled" tabindex="1"> |
| <option>EMP30001</option> |
| <option>EMP30002</option> |
| <option>EMP30003</option> |
| <option>EMP30004</option> |
| <option>EMP30005</option> |
| </select> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/collection.xml |
|---|
| 0,0 → 1,82 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - BR</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table id="table-1" border="4" frame="border" cellpadding="2" cellspacing="2" summary="HTML Control Table" rules="all"> |
| <caption>Table Caption</caption> |
| <thead align="center" valign="middle"> |
| <tr align="center" valign="middle" char="*" charoff="1"> |
| <th id="header-1">Employee Id</th> |
| <th id="header-2" abbr="maiden" axis="center" align="center" colspan="1" rowspan="1" scope="col" headers="header-1" valign="middle">Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| <th>Gender</th> |
| <th>Address</th> |
| </tr> |
| </thead> |
| <tfoot align="center" valign="middle"> |
| <tr> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| </tr> |
| </tfoot> |
| <tbody align="center" valign="middle"> |
| <tr> |
| <td axis="center" id="Table-3" abbr="maiden2" colspan="1" rowspan="1" scope="col" headers="header-2" valign="middle">EMP0001</td> |
| <td headers="header-2">Margaret Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| <td>Female</td> |
| <td>1230 North Ave. Dallas, Texas 98551</td> |
| </tr> |
| <tr> |
| <td>EMP0002</td> |
| <td>Martha Raynolds</td> |
| <td>Secretary</td> |
| <td>35,000</td> |
| <td>Female</td> |
| <td>1900 Dallas Road Dallas, Texas 98554</td> |
| </tr> |
| </tbody> |
| </table> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <select id="selectId" dir="ltr" tabindex="7" name="select1" multiple="multiple" size="1"> |
| <option selected="selected" value="EMP1">EMP10001</option> |
| <option>EMP10002</option> |
| <option>EMP10003</option> |
| <option>EMP10004</option> |
| <option>EMP10005</option> |
| </select> |
| </p> |
| </form> |
| <p> |
| <select name="select2"> |
| <option>EMP20001</option> |
| <option>EMP20002</option> |
| <option>EMP20003</option> |
| <option>EMP20004</option> |
| <option>EMP20005</option> |
| </select> |
| </p> |
| <p> |
| <select name="select3" disabled="disabled" tabindex="1"> |
| <option>EMP30001</option> |
| <option>EMP30002</option> |
| <option>EMP30003</option> |
| <option>EMP30004</option> |
| <option>EMP30005</option> |
| </select> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/directory.html |
|---|
| 0,0 → 1,14 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Directory</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <DIR COMPACT="compact"> |
| <LI>DIR item number 1.</LI> |
| <LI>DIR item number 2.</LI> |
| <LI>DIR item number 3.</LI> |
| </DIR> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/directory.xhtml |
|---|
| 0,0 → 1,16 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Directory</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <dir compact="compact"> |
| <li>DIR item number 1.</li> |
| <li>DIR item number 2.</li> |
| <li>DIR item number 3.</li> |
| </dir> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/directory.xml |
|---|
| 0,0 → 1,16 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Directory</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <dir compact="compact"> |
| <li>DIR item number 1.</li> |
| <li>DIR item number 2.</li> |
| <li>DIR item number 3.</li> |
| </dir> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/div.html |
|---|
| 0,0 → 1,10 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - DIV</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <DIV ALIGN="center">The DIV element is a generic block container. This text should be centered.</DIV> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/div.xhtml |
|---|
| 0,0 → 1,12 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - DIV</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <div align="center">The DIV element is a generic block container. This text should be centered.</div> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/div.xml |
|---|
| 0,0 → 1,12 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - DIV</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <div align="center">The DIV element is a generic block container. This text should be centered.</div> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/dl.html |
|---|
| 0,0 → 1,15 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - DL</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <DL COMPACT="COMPACT"> |
| <DD>Accountant</DD> |
| <DD>56,000</DD> |
| <DD>Female</DD> |
| <DD>1230 North Ave. Dallas, Texas 98551</DD> |
| </DL> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/dl.xhtml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - DL</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <dl compact="compact"> |
| <dd>Accountant</dd> |
| <dd>56,000</dd> |
| <dd>Female</dd> |
| <dd>1230 North Ave. Dallas, Texas 98551</dd> |
| </dl> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/dl.xml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - DL</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <dl compact="compact"> |
| <dd>Accountant</dd> |
| <dd>56,000</dd> |
| <dd>Female</dd> |
| <dd>1230 North Ave. Dallas, Texas 98551</dd> |
| </dl> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/document.html |
|---|
| 0,0 → 1,36 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - DOCUMENT</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()" ID="TEST-BODY"> |
| <FORM ID="form1" ACCEPT-CHARSET="US-ASCII" ACTION="./files/getData.pl" ENCTYPE="application/x-www-form-urlencoded" METHOD="post"> |
| <P> |
| <TEXTAREA NAME="text1" COLS="20" ROWS="7"></TEXTAREA> |
| <INPUT TYPE="submit" NAME="submit" VALUE="Submit" /> |
| <INPUT TYPE="reset" NAME="reset" VALUE="Reset" /> |
| </P> |
| </FORM> |
| <P> |
| <MAP NAME="mapid" ID="mapid"> |
| <AREA TABINDEX="10" ACCESSKEY="a" SHAPE="rect" ALT="Domain" COORDS="0,2,45,45" HREF="./files/dletter.html" TITLE="Domain1"> |
| <AREA TABINDEX="10" ACCESSKEY="a" SHAPE="rect" ALT="Domain" COORDS="0,2,45,45" HREF="./files/dletter.html" TITLE="Domain2"> |
| </MAP> |
| </P> |
| <P> |
| <IMG ID="IMAGE-1" NAME="IMAGE-1" SRC="./pix/dts.gif" ALT="DTS IMAGE LOGO" LONGDESC="./files/desc.html" USEMAP="#DTS-MAP" WIDTH="115"/> |
| </P> |
| <P> |
| <OBJECT DATA="./pix/line.gif" CODETYPE="image/gif" HEIGHT="10"> |
| <APPLET ALT="Applet Number 1" CODE="applet1.class"></APPLET> |
| </OBJECT> |
| <OBJECT DATA="./pix/logo.gif" type="image/gif"> |
| <APPLET ALT="Applet Number 2" CODE="applet2.class"></APPLET> |
| </OBJECT> |
| </P> |
| <P> |
| <A ID="Anchor" DIR="LTR" HREF="./pix/submit.gif" ACCESSKEY="g" TYPE="image/gif" COORDS="0,0,100,100" SHAPE="rect" REL="GLOSSARY" REV="STYLESHEET" HREFLANG="en" CHARSET="US-ASCII" TABINDEX="22" NAME="Anchor">View Submit Button</A> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/document.xhtml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - DOCUMENT</title> |
| </head> |
| <body onload="parent.loadComplete()" id="TEST-BODY"> |
| <form id="form1" accept-charset="US-ASCII" action="./files/getData.pl" enctype="application/x-www-form-urlencoded" method="post"> |
| <p> |
| <textarea name="text1" cols="20" rows="7"></textarea> |
| <input type="submit" name="submit1" value="Submit" /> |
| <input type="reset" name="submit2" value="Reset" /> |
| </p> |
| </form> |
| <p> |
| <map name="mapid" id="mapid"> |
| <area tabindex="10" accesskey="a" shape="rect" alt="Domain" coords="0,2,45,45" href="./files/dletter.html" title="Domain1" /> |
| <area tabindex="10" accesskey="a" shape="rect" alt="Domain" coords="0,2,45,45" href="./files/dletter.html" title="Domain2" /> |
| </map> |
| </p> |
| <p> |
| <img id="IMAGE-1" src="./pix/dts.gif" alt="DTS IMAGE LOGO" longdesc="./files/desc.html" usemap="#DTS-MAP" width="115"/> |
| </p> |
| <p> |
| <object data="./pix/line.gif" codetype="image/gif" height="10"> |
| <applet alt="Applet Number 1" code="applet1.class" width="10" height="10"></applet> |
| </object> |
| <object data="./pix/logo.gif" type="image/gif"> |
| <applet alt="Applet Number 2" code="applet2.class" width="10" height="10"></applet> |
| </object> |
| </p> |
| <p> |
| <a id="Anchor" dir="ltr" href="./pix/submit.gif" accesskey="g" type="image/gif" coords="0,0,100,100" shape="rect" rel="GLOSSARY" rev="STYLESHEET" hreflang="en" charset="US-ASCII" tabindex="22" name="Anchor">View Submit Button</a> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/document.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - DOCUMENT</title> |
| </head> |
| <body onload="parent.loadComplete()" id="TEST-BODY"> |
| <form id="form1" accept-charset="US-ASCII" action="./files/getData.pl" enctype="application/x-www-form-urlencoded" method="post"> |
| <p> |
| <textarea name="text1" cols="20" rows="7"></textarea> |
| <input type="submit" name="submit1" value="Submit" /> |
| <input type="reset" name="submit2" value="Reset" /> |
| </p> |
| </form> |
| <p> |
| <map name="mapid" id="mapid"> |
| <area tabindex="10" accesskey="a" shape="rect" alt="Domain" coords="0,2,45,45" href="./files/dletter.html" title="Domain1" /> |
| <area tabindex="10" accesskey="a" shape="rect" alt="Domain" coords="0,2,45,45" href="./files/dletter.html" title="Domain2" /> |
| </map> |
| </p> |
| <p> |
| <img id="IMAGE-1" src="./pix/dts.gif" alt="DTS IMAGE LOGO" longdesc="./files/desc.html" usemap="#DTS-MAP" width="115"/> |
| </p> |
| <p> |
| <object data="./pix/line.gif" codetype="image/gif" height="10"> |
| <applet alt="Applet Number 1" code="applet1.class" width="10" height="10"></applet> |
| </object> |
| <object data="./pix/logo.gif" type="image/gif"> |
| <applet alt="Applet Number 2" code="applet2.class" width="10" height="10"></applet> |
| </object> |
| </p> |
| <p> |
| <a id="Anchor" dir="ltr" href="./pix/submit.gif" accesskey="g" type="image/gif" coords="0,0,100,100" shape="rect" rel="GLOSSARY" rev="STYLESHEET" hreflang="en" charset="US-ASCII" tabindex="22" name="Anchor">View Submit Button</a> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/element.html |
|---|
| 0,0 → 1,81 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD ID="Test-HEAD" TITLE="HEAD Element" LANG="en" DIR="ltr" CLASS="HEAD-class"> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Element</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <CENTER ID="Test-CENTER" TITLE="CENTER Element" LANG="en" DIR="ltr" CLASS="CENTER-class"> |
| <OBJECT align="middle"></OBJECT> |
| </CENTER> |
| <CENTER> |
| <P align="center">Test Lists</P> |
| </CENTER> |
| <BR> |
| <OL compact="compact" start="1" type="1"> |
| <LI type="square" value=2>EMP0001 |
| <UL compact type="disc"> |
| <LI>Margaret Martin |
| <DL> |
| <DD ID="Test-DD" TITLE="DD Element" LANG="en" DIR="ltr" CLASS="DD-class">Accountant</DD> |
| <DD>56,000</DD> |
| <DD>Female</DD> |
| <DD>1230 North Ave. Dallas, Texas 98551</DD> |
| </DL> |
| </LI> |
| </UL> |
| </LI> |
| </OL> |
| <BR /> |
| <B ID="Test-B" TITLE="B Element" LANG="en" DIR="ltr" CLASS="B-class">Bold</B> |
| <BR /> |
| <DL> |
| <DT ID="Test-DT" TITLE="DT Element" LANG="en" DIR="ltr" CLASS="DT-class">DT element</DT> |
| </DL> |
| <BR /> |
| <BDO ID="Test-BDO" TITLE="BDO Element" LANG="en" DIR="ltr" CLASS="BDO-class">Bidirectional algorithm overide |
| </BDO> |
| <BR /> |
| <I ID="Test-I" TITLE="I Element" LANG="en" DIR="ltr" CLASS="I-class">Italicized</I> |
| <BR /> |
| <SPAN ID="Test-SPAN" TITLE="SPAN Element" LANG="en" DIR="ltr" CLASS="SPAN-class"></SPAN> |
| <BR /> |
| <TT ID="Test-TT" TITLE="TT Element" LANG="en" DIR="ltr" CLASS="TT-class">Teletype</TT> |
| <BR /> |
| <SUB ID="Test-SUB" TITLE="SUB Element" LANG="en" DIR="ltr" CLASS="SUB-class">Subscript</SUB> |
| <BR /> |
| <SUP ID="Test-SUP" TITLE="SUP Element" LANG="en" DIR="ltr" CLASS="SUP-class">SuperScript</SUP> |
| <BR /> |
| <S ID="Test-S" TITLE="S Element" LANG="en" DIR="ltr" CLASS="S-class">Strike Through (S)</S> |
| <BR /> |
| <STRIKE ID="Test-STRIKE" TITLE="STRIKE Element" LANG="en" DIR="ltr" CLASS="STRIKE-class">Strike Through (STRIKE)</STRIKE> |
| <BR /> |
| <SMALL id="Test-SMALL" TITLE="SMALL Element" LANG="en" DIR="ltr" CLASS="SMALL-class">Small</SMALL> |
| <BR /> |
| <BIG ID="Test-BIG" TITLE="BIG Element" LANG="en" DIR="ltr" CLASS="BIG-class">Big</BIG> |
| <BR /> |
| <EM ID="Test-EM" TITLE="EM Element" LANG="en" DIR="ltr" CLASS="EM-class">Emphasis</EM> |
| <BR /> |
| <STRONG ID="Test-STRONG" TITLE="STRONG Element" LANG="en" DIR="ltr" CLASS="STRONG-class">Strong</STRONG> |
| <BR /> |
| <DFN ID="Test-DFN" TITLE="DFN Element" LANG="en" DIR="ltr" CLASS="DFN-class"> |
| <CODE ID="Test-CODE" TITLE="CODE Element" LANG="en" DIR="ltr" CLASS="CODE-class">10 Computer Code Fragment 20 Temp = 10</CODE> |
| <SAMP ID="Test-SAMP" TITLE="SAMP Element" LANG="en" DIR="ltr" CLASS="SAMP-class">Temp = 20</SAMP> |
| <KBD ID="Test-KBD" TITLE="KBD Element" LANG="en" DIR="ltr" CLASS="KBD-class">*2</KBD> |
| <VAR ID="Test-VAR" TITLE="VAR Element" LANG="en" DIR="ltr" CLASS="VAR-class">Temp</VAR> |
| <CITE ID="Test-CITE" TITLE="CITE Element" LANG="en" DIR="ltr" CLASS="CITE-class">Citation</CITE> |
| </DFN> |
| <BR /> |
| <ABBR ID="Test-ABBR" TITLE="ABBR Element" LANG="en" DIR="ltr" CLASS="ABBR-class">Temp</ABBR> |
| <BR /> |
| <ACRONYM ID="Test-ACRONYM" TITLE="ACRONYM Element" LANG="en" DIR="ltr" CLASS="ACRONYM-class">NIST</ACRONYM> |
| <BR /> |
| <ADDRESS ID="Test-ADDRESS" TITLE="ADDRESS Element" LANG="en" DIR="ltr" CLASS="ADDRESS-class">Gaithersburg, MD 20899</ADDRESS> |
| <BR /> |
| <NOFRAMES ID="Test-NOFRAMES" TITLE="NOFRAMES Element" LANG="en" DIR="ltr" CLASS="NOFRAMES-class">Not</NOFRAMES> |
| <BR /> |
| <NOSCRIPT ID="Test-NOSCRIPT" TITLE="NOSCRIPT Element" LANG="en" DIR="ltr" CLASS="NOSCRIPT-class">Not</NoScript> |
| <BR /> |
| <U ID="Test-U" TITLE="U Element" LANG="en" DIR="ltr" CLASS="U-class">Underlined</U> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/element.xhtml |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html lang="en" dir="ltr" xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Element</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <center id="Test-CENTER" title="CENTER Element" lang="en" dir="ltr" class="CENTER-class"> |
| <object align="middle"></object> |
| </center> |
| <center> |
| <p align="center">Test Lists</p> |
| </center> |
| <br /> |
| <ol compact="compact" start="1" type="1"> |
| <li type="square" value="2">EMP0001 |
| <ul compact="compact" type="disc"> |
| <li>Margaret Martin |
| <dl> |
| <dd id="Test-DD" title="DD Element" lang="en" dir="ltr" class="DD-class">Accountant</dd> |
| <dd>56,000</dd> |
| <dd>Female</dd> |
| <dd>1230 North Ave. Dallas, Texas 98551</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| </ol> |
| <br /> |
| <b id="Test-B" title="B Element" lang="en" dir="ltr" class="B-class">Bold</b> |
| <br /> |
| <dl> |
| <dt id="Test-DT" title="DT Element" lang="en" dir="ltr" class="DT-class">DT element</dt> |
| </dl> |
| <br /> |
| <bdo id="Test-BDO" title="BDO Element" lang="en" dir="ltr" class="BDO-class">Bidirectional algorithm overide |
| </bdo> |
| <br /> |
| <i id="Test-I" title="I Element" lang="en" dir="ltr" class="I-class">Italicized</i> |
| <br /> |
| <span id="Test-SPAN" title="SPAN Element" lang="en" dir="ltr" class="SPAN-class"></span> |
| <br /> |
| <tt id="Test-TT" title="TT Element" lang="en" dir="ltr" class="TT-class">Teletype</tt> |
| <br /> |
| <sub id="Test-SUB" title="SUB Element" lang="en" dir="ltr" class="SUB-class">Subscript</sub> |
| <br /> |
| <sup id="Test-SUP" title="SUP Element" lang="en" dir="ltr" class="SUP-class">SuperScript</sup> |
| <br /> |
| <s id="Test-S" title="S Element" lang="en" dir="ltr" class="S-class">Strike Through (S)</s> |
| <br /> |
| <strike id="Test-STRIKE" title="STRIKE Element" lang="en" dir="ltr" class="STRIKE-class">Strike Through (STRIKE)</strike> |
| <br /> |
| <small id="Test-SMALL" title="SMALL Element" lang="en" dir="ltr" class="SMALL-class">Small</small> |
| <br /> |
| <big id="Test-BIG" title="BIG Element" lang="en" dir="ltr" class="BIG-class">Big</big> |
| <br /> |
| <em id="Test-EM" title="EM Element" lang="en" dir="ltr" class="EM-class">Emphasis</em> |
| <br /> |
| <strong id="Test-STRONG" title="STRONG Element" lang="en" dir="ltr" class="STRONG-class">Strong</strong> |
| <br /> |
| <dfn id="Test-DFN" title="DFN Element" lang="en" dir="ltr" class="DFN-class"> |
| <code id="Test-CODE" title="CODE Element" lang="en" dir="ltr" class="CODE-class">10 Computer Code Fragment 20 Temp = 10</code> |
| <samp id="Test-SAMP" title="SAMP Element" lang="en" dir="ltr" class="SAMP-class">Temp = 20</samp> |
| <kbd id="Test-KBD" title="KBD Element" lang="en" dir="ltr" class="KBD-class">*2</kbd> |
| <var id="Test-VAR" title="VAR Element" lang="en" dir="ltr" class="VAR-class">Temp</var> |
| <cite id="Test-CITE" title="CITE Element" lang="en" dir="ltr" class="CITE-class">Citation</cite> |
| </dfn> |
| <br /> |
| <abbr id="Test-ABBR" title="ABBR Element" lang="en" dir="ltr" class="ABBR-class">Temp</abbr> |
| <br /> |
| <acronym id="Test-ACRONYM" title="ACRONYM Element" lang="en" dir="ltr" class="ACRONYM-class">NIST</acronym> |
| <br /> |
| <address id="Test-ADDRESS" title="ADDRESS Element" lang="en" dir="ltr" class="ADDRESS-class">Gaithersburg, MD 20899</address> |
| <br /> |
| <noframes id="Test-NOFRAMES" title="NOFRAMES Element" lang="en" dir="ltr" class="NOFRAMES-class">Not</noframes> |
| <br /> |
| <noscript id="Test-NOSCRIPT" title="NOSCRIPT Element" lang="en" dir="ltr" class="NOSCRIPT-class">Not</noscript> |
| <br /> |
| <u id="Test-U" title="U Element" lang="en" dir="ltr" class="U-class">Underlined</u> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/element.xml |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html lang="en" dir="ltr" xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Element</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <center id="Test-CENTER" title="CENTER Element" lang="en" dir="ltr" class="CENTER-class"> |
| <object align="middle"></object> |
| </center> |
| <center> |
| <p align="center">Test Lists</p> |
| </center> |
| <br /> |
| <ol compact="compact" start="1" type="1"> |
| <li type="square" value="2">EMP0001 |
| <ul compact="compact" type="disc"> |
| <li>Margaret Martin |
| <dl> |
| <dd id="Test-DD" title="DD Element" lang="en" dir="ltr" class="DD-class">Accountant</dd> |
| <dd>56,000</dd> |
| <dd>Female</dd> |
| <dd>1230 North Ave. Dallas, Texas 98551</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| </ol> |
| <br /> |
| <b id="Test-B" title="B Element" lang="en" dir="ltr" class="B-class">Bold</b> |
| <br /> |
| <dl> |
| <dt id="Test-DT" title="DT Element" lang="en" dir="ltr" class="DT-class">DT element</dt> |
| </dl> |
| <br /> |
| <bdo id="Test-BDO" title="BDO Element" lang="en" dir="ltr" class="BDO-class">Bidirectional algorithm overide |
| </bdo> |
| <br /> |
| <i id="Test-I" title="I Element" lang="en" dir="ltr" class="I-class">Italicized</i> |
| <br /> |
| <span id="Test-SPAN" title="SPAN Element" lang="en" dir="ltr" class="SPAN-class"></span> |
| <br /> |
| <tt id="Test-TT" title="TT Element" lang="en" dir="ltr" class="TT-class">Teletype</tt> |
| <br /> |
| <sub id="Test-SUB" title="SUB Element" lang="en" dir="ltr" class="SUB-class">Subscript</sub> |
| <br /> |
| <sup id="Test-SUP" title="SUP Element" lang="en" dir="ltr" class="SUP-class">SuperScript</sup> |
| <br /> |
| <s id="Test-S" title="S Element" lang="en" dir="ltr" class="S-class">Strike Through (S)</s> |
| <br /> |
| <strike id="Test-STRIKE" title="STRIKE Element" lang="en" dir="ltr" class="STRIKE-class">Strike Through (STRIKE)</strike> |
| <br /> |
| <small id="Test-SMALL" title="SMALL Element" lang="en" dir="ltr" class="SMALL-class">Small</small> |
| <br /> |
| <big id="Test-BIG" title="BIG Element" lang="en" dir="ltr" class="BIG-class">Big</big> |
| <br /> |
| <em id="Test-EM" title="EM Element" lang="en" dir="ltr" class="EM-class">Emphasis</em> |
| <br /> |
| <strong id="Test-STRONG" title="STRONG Element" lang="en" dir="ltr" class="STRONG-class">Strong</strong> |
| <br /> |
| <dfn id="Test-DFN" title="DFN Element" lang="en" dir="ltr" class="DFN-class"> |
| <code id="Test-CODE" title="CODE Element" lang="en" dir="ltr" class="CODE-class">10 Computer Code Fragment 20 Temp = 10</code> |
| <samp id="Test-SAMP" title="SAMP Element" lang="en" dir="ltr" class="SAMP-class">Temp = 20</samp> |
| <kbd id="Test-KBD" title="KBD Element" lang="en" dir="ltr" class="KBD-class">*2</kbd> |
| <var id="Test-VAR" title="VAR Element" lang="en" dir="ltr" class="VAR-class">Temp</var> |
| <cite id="Test-CITE" title="CITE Element" lang="en" dir="ltr" class="CITE-class">Citation</cite> |
| </dfn> |
| <br /> |
| <abbr id="Test-ABBR" title="ABBR Element" lang="en" dir="ltr" class="ABBR-class">Temp</abbr> |
| <br /> |
| <acronym id="Test-ACRONYM" title="ACRONYM Element" lang="en" dir="ltr" class="ACRONYM-class">NIST</acronym> |
| <br /> |
| <address id="Test-ADDRESS" title="ADDRESS Element" lang="en" dir="ltr" class="ADDRESS-class">Gaithersburg, MD 20899</address> |
| <br /> |
| <noframes id="Test-NOFRAMES" title="NOFRAMES Element" lang="en" dir="ltr" class="NOFRAMES-class">Not</noframes> |
| <br /> |
| <noscript id="Test-NOSCRIPT" title="NOSCRIPT Element" lang="en" dir="ltr" class="NOSCRIPT-class">Not</noscript> |
| <br /> |
| <u id="Test-U" title="U Element" lang="en" dir="ltr" class="U-class">Underlined</u> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/fieldset.html |
|---|
| 0,0 → 1,23 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - FieldSet</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form2" ACTION="..." METHOD="POST"> |
| <FIELDSET> |
| <LEGEND>All data entered must be valid</LEGEND> |
| </FIELDSET> |
| </FORM> |
| <TABLE SUMMARY="Table 1"> |
| <TR> |
| <TD> |
| <FIELDSET> |
| <LEGEND>All data entered must be valid</LEGEND> |
| </FIELDSET> |
| </TD> |
| </TR> |
| </TABLE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/fieldset.xhtml |
|---|
| 0,0 → 1,25 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FieldSet</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form2" action="..." method="post"> |
| <fieldset> |
| <legend>All data entered must be valid</legend> |
| </fieldset> |
| </form> |
| <table summary="Table 1"> |
| <tr> |
| <td> |
| <fieldset> |
| <legend>All data entered must be valid</legend> |
| </fieldset> |
| </td> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/fieldset.xml |
|---|
| 0,0 → 1,25 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FieldSet</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form2" action="..." method="post"> |
| <fieldset> |
| <legend>All data entered must be valid</legend> |
| </fieldset> |
| </form> |
| <table summary="Table 1"> |
| <tr> |
| <td> |
| <fieldset> |
| <legend>All data entered must be valid</legend> |
| </fieldset> |
| </td> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/font.html |
|---|
| 0,0 → 1,10 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Font</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FONT COLOR="#000000" FACE="arial,helvetica" SIZE="4">Test Tables</FONT> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/font.xhtml |
|---|
| 0,0 → 1,12 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - BaseFont</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <font color="#000000" face="arial,helvitica" size="4">Test Tables</font> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/font.xml |
|---|
| 0,0 → 1,12 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - BaseFont</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <font color="#000000" face="arial,helvitica" size="4">Test Tables</font> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/form.html |
|---|
| 0,0 → 1,17 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - FORM</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form1" ACCEPT-CHARSET="US-ASCII" ACTION="./files/getData.pl" ENCTYPE="application/x-www-form-urlencoded" METHOD="post"> |
| <P> |
| <TEXTAREA NAME="text1" COLS="20" ROWS="7"></TEXTAREA> |
| <INPUT TYPE="submit" NAME="submit1" VALUE="Submit" /> |
| <INPUT TYPE="reset" NAME="submit2" VALUE="Reset" /> |
| </P> |
| </FORM> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/form.xhtml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FORM</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" accept-charset="US-ASCII" action="./files/getData.pl" enctype="application/x-www-form-urlencoded" method="post"> |
| <p> |
| <textarea id="text1" cols="20" rows="7"></textarea> |
| <input type="submit" name="submit1" value="Submit" /> |
| <input type="reset" name="submit2" value="Reset" /> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/form.xml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FORM</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" accept-charset="US-ASCII" action="./files/getData.pl" enctype="application/x-www-form-urlencoded" method="post"> |
| <p> |
| <textarea id="text1" cols="20" rows="7"></textarea> |
| <input type="submit" name="submit1" value="Submit" /> |
| <input type="reset" name="submit2" value="Reset" /> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/form2.html |
|---|
| 0,0 → 1,17 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" |
| "http://www.w3.org/TR/html4/loose.dtd"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - FORM</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form1" TARGET="dynamic" ACCEPT-CHARSET="US-ASCII" ACTION="./files/getData.pl" ENCTYPE="application/x-www-form-urlencoded" METHOD="post"> |
| <P> |
| <TEXTAREA NAME="text1" COLS="20" ROWS="7"></TEXTAREA> |
| <INPUT TYPE="submit" NAME="submit1" VALUE="Submit" /> |
| <INPUT TYPE="reset" NAME="submit2" VALUE="Reset" /> |
| </P> |
| </FORM> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/form2.xhtml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FORM</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" target="dynamic" accept-charset="US-ASCII" action="./files/getData.pl" enctype="application/x-www-form-urlencoded" method="post"> |
| <p> |
| <textarea id="text1" cols="20" rows="7"></textarea> |
| <input type="submit" name="submit1" value="Submit" /> |
| <input type="reset" name="submit2" value="Reset" /> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/form2.xml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FORM</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" target="dynamic" accept-charset="US-ASCII" action="./files/getData.pl" enctype="application/x-www-form-urlencoded" method="post"> |
| <p> |
| <textarea id="text1" cols="20" rows="7"></textarea> |
| <input type="submit" name="submit1" value="Submit" /> |
| <input type="reset" name="submit2" value="Reset" /> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/form3.html |
|---|
| 0,0 → 1,17 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>FORM3</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form1" ACTION="about:blank"> |
| <P> |
| <TEXTAREA NAME="text1" COLS="20" ROWS="7"></TEXTAREA> |
| <INPUT TYPE="submit" NAME="submit1" VALUE="Submit" /> |
| <INPUT TYPE="reset" NAME="submit2" VALUE="Reset" /> |
| </P> |
| </FORM> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/form3.xhtml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>FORM3</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="about:blank"> |
| <p> |
| <textarea id="text1" cols="20" rows="7"></textarea> |
| <input type="submit" name="submit1" value="Submit" /> |
| <input type="reset" name="submit2" value="Reset" /> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/form3.xml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>FORM3</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="about:blank"> |
| <p> |
| <textarea id="text1" cols="20" rows="7"></textarea> |
| <input type="submit" name="submit1" value="Submit" /> |
| <input type="reset" name="submit2" value="Reset" /> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/frame.html |
|---|
| 0,0 → 1,14 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" |
| "http://www.w3.org/TR/html4/frameset.dtd"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - FRAME</TITLE> |
| </HEAD> |
| <FRAMESET COLS="20, 80" onload="parent.loadComplete()"> |
| <FRAMESET ROWS="100, 200"> |
| <FRAME LONGDESC="about:blank" MARGINHEIGHT="10" MARGINWIDTH="5" NORESIZE="NORESIZE" NAME="Frame1" FRAMEBORDER="1" SCROLLING="yes" SRC="right.png"> |
| </FRAMESET> |
| <FRAME SRC="w3c_main.png"> |
| </FRAMESET> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/frame.xhtml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" |
| "xhtml1-frameset.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FRAME</title> |
| </head> |
| <frameset cols="20, 80" onload="parent.loadComplete()"> |
| <frameset rows="100, 200"> |
| <frame longdesc="about:blank" marginheight="10" marginwidth="5" noresize="noresize" name="Frame1" frameborder="1" scrolling="yes" src="right.png" /> |
| </frameset> |
| <frame src="w3c_main.png" /> |
| </frameset> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/frame.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" |
| "xhtml1-frameset.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FRAME</title> |
| </head> |
| <frameset cols="20, 80" onload="parent.loadComplete()"> |
| <frameset rows="100, 200"> |
| <frame longdesc="about:blank" marginheight="10" marginwidth="5" noresize="noresize" name="Frame1" frameborder="1" scrolling="yes" src="right.png" /> |
| </frameset> |
| <frame src="w3c_main.png" /> |
| </frameset> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/frameset.html |
|---|
| 0,0 → 1,14 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" |
| "http://www.w3.org/TR/html4/frameset.dtd"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - FRAMESET</TITLE> |
| </HEAD> |
| <FRAMESET COLS="20, 80" onload="parent.loadComplete()"> |
| <FRAMESET ROWS="100, 200"> |
| <FRAME SRC="right.png"> |
| </FRAMESET> |
| <FRAME SRC="w3c_main.png"> |
| </FRAMESET> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/frameset.xhtml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" |
| "xhtml1-frameset.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FRAMESET</title> |
| </head> |
| <frameset cols="20, 80" onload="parent.loadComplete()"> |
| <frameset rows="100, 200"> |
| <frame src="right.png" /> |
| </frameset> |
| <frame src="w3c_main.png" /> |
| </frameset> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/frameset.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" |
| "xhtml1-frameset.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FRAMESET</title> |
| </head> |
| <frameset cols="20, 80" onload="parent.loadComplete()"> |
| <frameset rows="100, 200"> |
| <frame src="right.png" /> |
| </frameset> |
| <frame src="w3c_main.png" /> |
| </frameset> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/head.html |
|---|
| 0,0 → 1,11 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD PROFILE="http://www.w3.org/2004/07/profile"> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - HEAD</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P>Hello, World.</P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/head.xhtml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head profile="http://www.w3.org/2004/07/profile"> |
| <title>NIST DOM HTML Test - HEAD</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>Hello, World.</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/head.xml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head profile="http://xw2k.sdct.itl.nist.gov/brady/dom/files/profile"> |
| <title>NIST DOM HTML Test - HEAD</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>Hello, World.</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/heading.html |
|---|
| 0,0 → 1,16 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - HEADING</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <H1 ALIGN="center">Head Element 1</H1> |
| <H2 ALIGN="left">Head Element 2</H2> |
| <H3 ALIGN="right">Head Element 3</H3> |
| <H4 ALIGN="justify">Head Element 4</H4> |
| <H5 ALIGN="center">Head Element 5</H5> |
| <H6 ALIGN="left">Head Element 6</H6> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/heading.xhtml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - HEADING</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <h1 align="center">Head Element 1</h1> |
| <h2 align="left">Head Element 2</h2> |
| <h3 align="right">Head Element 3</h3> |
| <h4 align="right">Head Element 4</h4> |
| <h5 align="center">Head Element 5</h5> |
| <h6 align="left">Head Element 6</h6> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/heading.xml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - HEADING</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <h1 align="center">Head Element 1</h1> |
| <h2 align="left">Head Element 2</h2> |
| <h3 align="right">Head Element 3</h3> |
| <h4 align="right">Head Element 4</h4> |
| <h5 align="center">Head Element 5</h5> |
| <h6 align="left">Head Element 6</h6> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/hr.html |
|---|
| 0,0 → 1,11 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - HR</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <HR ALIGN="center" NOSHADE="noShade" SIZE="5" WIDTH="400" /> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/hr.xhtml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - HR</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <hr align="center" noshade="noshade" size="5" width="400"/> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/hr.xml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - HR</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <hr align="center" noshade="noshade" size="5" width="400"/> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/html.html |
|---|
| 0,0 → 1,12 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML VERSION="-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - Html</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P>Hello, World.</P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/html.xhtml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Html</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>Hello, World.</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/html.xml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - Html</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>Hello, World.</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/iframe.html |
|---|
| 0,0 → 1,10 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - IFRAME</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <IFRAME LONGDESC="about:blank" MARGINHEIGHT="10" MARGINWIDTH="5" WIDTH="60" HEIGHT="50" NAME="Iframe1" FRAMEBORDER="1" SCROLLING="yes" SRC="right.png" ALIGN="top">IFRAME1</IFRAME> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/iframe.xhtml |
|---|
| 0,0 → 1,12 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - IFRAME</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <iframe longdesc="about:blank" marginheight="10" marginwidth="5" width="60" height="50" name="Iframe1" frameborder="1" scrolling="yes" src="right.png" align="top">IFRAME1</iframe> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/iframe.xml |
|---|
| 0,0 → 1,12 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - IFRAME</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <iframe longdesc="about:blank" marginheight="10" marginwidth="5" width="60" height="50" name="Iframe1" frameborder="1" scrolling="yes" src="right.png" align="top">IFRAME1</iframe> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/img.html |
|---|
| 0,0 → 1,13 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - IMG</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <IMG ID="IMAGE-1" NAME="IMAGE-1" SRC="./pix/dts.gif" ALIGN="middle" ALT="DTS IMAGE LOGO" BORDER="0" HEIGHT="47" HSPACE="4" LONGDESC="./files/desc.html" USEMAP="#DTS-MAP" VSPACE="10" WIDTH="115"/> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/img.xhtml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - IMG</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <img id="IMAGE-1" name="IMAGE-1" src="./pix/dts.gif" align="middle" alt="DTS IMAGE LOGO" border="0" height="47" hspace="4" longdesc="./files/desc.html" usemap="#DTS-MAP" vspace="10" width="115"/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/img.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - IMG</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <img id="IMAGE-1" name="IMAGE-1" src="./pix/dts.gif" align="middle" alt="DTS IMAGE LOGO" border="0" height="47" hspace="4" longdesc="./files/desc.html" usemap="#DTS-MAP" vspace="10" width="115"/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/input.html |
|---|
| 0,0 → 1,60 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - INPUT</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <TABLE CELLPADDING="15" BORDER="BORDER" SUMMARY="Table 1"> |
| <TR ALIGN="center"> |
| <TD VAlign="top">Under a FORM control |
| <FORM ID="form1" ACTION="./files/getData.pl" METHOD="post"> |
| <TABLE BORDER="15" SUMMARY="Table 2"> |
| <TR> |
| <TD> |
| <LABEL ACCESSKEY="b" FOR="input1">Enter Your Password:</LABEL> |
| </TD> |
| <TD> |
| <INPUT DIR="LTR" ID="input1" TABINDEX="8" VALUE="Password" TYPE="password" NAME="Password" SIZE="25" MAXLENGTH="5" ALT="Password entry" READONLY="READONLY"/> |
| </TD> |
| </TR> |
| <TR> |
| <TD> |
| <INPUT TYPE="RADIO" NAME="Radio1" ACCESSKEY="c" VALUE="ReHire"/>ReHire |
| </TD> |
| </TR> |
| <TR> |
| <TD> |
| <INPUT TYPE="RADIO" NAME="Radio2" VALUE="NewHire" TABINDEX="9" CHECKED="CHECKED"/>NewHire |
| </TD> |
| </TR> |
| <TR> |
| <TD>Hours available to work</TD> |
| <TD> |
| <INPUT TYPE="CHECKBOX" NAME="Check1" ALIGN="bottom" TABINDEX="10" VALUE="EarlyMornings" CHECKED="CHECKED"/>EarlyMornings |
| <BR/> |
| <INPUT ID="input5" TYPE="CHECKBOX" NAME="Check2" TABINDEX="11" VALUE="AfterNoon" ONCLICK="newId(this)"/>Afternoon |
| <BR/> |
| <INPUT TYPE="CHECKBOX" NAME="Check3" TABINDEX="12" VALUE="Evenings"/>Evenings |
| <BR/> |
| <INPUT TYPE="CHECKBOX" NAME="Check4" TABINDEX="13" VALUE="Closing" DISABLED="DISABLED"/>Closing |
| <BR/> |
| </TD> |
| </TR> |
| <TR> |
| <TD COLSPAN="2"> |
| <INPUT TYPE="IMAGE" TABINDEX="14" NAME="SubmitImage" USEMAP="#submit-map" SRC="./pix/submit.gif"/> |
| </TD> |
| </TR> |
| <TR> |
| <TD COLSPAN="2"> |
| <INPUT TITLE="old_title" TYPE="FILE" NAME="FileControl" TABINDEX="15" ACCEPT="GIF,JPEG" ONSELECT="newTitle(this)"/> |
| </TD> |
| </TR> |
| </TABLE> |
| </FORM> |
| </TD> |
| </TR> |
| </TABLE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/input.xhtml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - INPUT</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table cellpadding="15" border="border" summary="Table 1"> |
| <tr align="center"> |
| <td valign="top">Under a FORM control |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <table border="15" summary="Table 2"> |
| <tr> |
| <td> |
| <label accesskey="b" for="input1">Enter Your Password:</label> |
| </td> |
| <td> |
| <input dir="ltr" id="input1" tabindex="8" value="Password" type="password" name="Password" size="25" maxlength="5" alt="Password entry" readonly="readonly"/> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| <input type="radio" name="Radio1" accesskey="c" value="ReHire"/> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| <input type="radio" name="Radio2" value="NewHire" tabindex="9" checked="checked"/> |
| </td> |
| </tr> |
| <tr> |
| <td>Hours available to work</td> |
| <td> |
| <input type="checkbox" name="Check1" align="bottom" tabindex="10" value="EarlyMornings" checked="checked"/> |
| <br/> |
| <input id="input5" type="checkbox" name="Check2" tabindex="11" value="AfterNoon" onclick="newId(this)"/> |
| <br/> |
| <input type="checkbox" name="Check3" tabindex="12" value="Evenings"/> |
| <br/> |
| <input type="checkbox" name="Check4" tabindex="13" value="Closing" disabled="disabled"/> |
| <br/> |
| </td> |
| </tr> |
| <tr> |
| <td colspan="2"> |
| <input type="image" tabindex="14" name="SubmitImage" usemap="#submit-map" src="./pix/submit.gif"/> |
| </td> |
| </tr> |
| <tr> |
| <td colspan="2"> |
| <input title="old_title" type="file" name="FileControl" tabindex="15" accept="GIF,JPEG" onselect="newTitle(this)"/> |
| </td> |
| </tr> |
| </table> |
| </form> |
| </td> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/input.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - INPUT</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table cellpadding="15" border="border" summary="Table 1"> |
| <tr align="center"> |
| <td valign="top">Under a FORM control |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <table border="15" summary="Table 2"> |
| <tr> |
| <td> |
| <label accesskey="b" for="input1">Enter Your Password:</label> |
| </td> |
| <td> |
| <input dir="ltr" id="input1" tabindex="8" value="Password" type="password" name="Password" size="25" maxlength="5" alt="Password entry" readonly="readonly"/> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| <input type="radio" name="Radio1" accesskey="c" value="ReHire"/> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| <input type="radio" name="Radio2" value="NewHire" tabindex="9" checked="checked"/> |
| </td> |
| </tr> |
| <tr> |
| <td>Hours available to work</td> |
| <td> |
| <input type="checkbox" name="Check1" align="bottom" tabindex="10" value="EarlyMornings" checked="checked"/> |
| <br/> |
| <input id="input5" type="checkbox" name="Check2" tabindex="11" value="AfterNoon" onclick="newId(this)"/> |
| <br/> |
| <input type="checkbox" name="Check3" tabindex="12" value="Evenings"/> |
| <br/> |
| <input type="checkbox" name="Check4" tabindex="13" value="Closing" disabled="disabled"/> |
| <br/> |
| </td> |
| </tr> |
| <tr> |
| <td colspan="2"> |
| <input type="image" tabindex="14" name="SubmitImage" usemap="#submit-map" src="./pix/submit.gif"/> |
| </td> |
| </tr> |
| <tr> |
| <td colspan="2"> |
| <input title="old_title" type="file" name="FileControl" tabindex="15" accept="GIF,JPEG" onselect="newTitle(this)"/> |
| </td> |
| </tr> |
| </table> |
| </form> |
| </td> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/isindex.html |
|---|
| 0,0 → 1,14 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - ISINDEX</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form1" ACTION="./files/getData.pl" METHOD="post"> |
| <ISINDEX PROMPT="New Employee: "> |
| </FORM> |
| <ISINDEX PROMPT="Old Employee: "> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/isindex.xhtml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - ISINDEX</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <isindex prompt="New Employee: "/> |
| </form> |
| <isindex prompt="Old Employee: "/> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/isindex.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - ISINDEX</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <isindex prompt="New Employee: "/> |
| </form> |
| <isindex prompt="Old Employee: "/> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/label.html |
|---|
| 0,0 → 1,21 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - LABEL</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form1" ACTION="./files/getData.pl" METHOD="post"> |
| <P> |
| <LABEL ACCESSKEY="b" FOR="input1">Enter Your First Password:</LABEL> |
| <INPUT ID="input1" TYPE="password" NAME="Password1"/> |
| </P> |
| </FORM> |
| <P> |
| <LABEL ACCESSKEY="c" FOR="input2">Enter Your Second Password:</LABEL> |
| <INPUT ID="input2" TYPE="password" NAME="Password2"/> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/label.xhtml |
|---|
| 0,0 → 1,22 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - LABEL</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <label accesskey="b" for="input1">Enter Your First Password:</label> |
| <input id="input1" type="password" name="Password1"/> |
| </p> |
| </form> |
| <p> |
| <label accesskey="c" for="input2">Enter Your Second Password:</label> |
| <input id="input2" type="password" name="Password2"/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/label.xml |
|---|
| 0,0 → 1,22 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - LABEL</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <label accesskey="b" for="input1">Enter Your First Password:</label> |
| <input id="input1" type="password" name="Password1"/> |
| </p> |
| </form> |
| <p> |
| <label accesskey="c" for="input2">Enter Your Second Password:</label> |
| <input id="input2" type="password" name="Password2"/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/legend.html |
|---|
| 0,0 → 1,22 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - LEGEND</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form1" ACTION="./files/getData.pl" METHOD="post"> |
| <FIELDSET> |
| <LEGEND ACCESSKEY="b" ALIGN="top">Enter Password1:</LEGEND> |
| <INPUT ID="input1" TYPE="password" NAME="Password1"/> |
| </FIELDSET> |
| </FORM> |
| <FIELDSET> |
| <LEGEND ACCESSKEY="c" ALIGN="bottom">Enter Password2:</LEGEND> |
| <INPUT ID="input2" TYPE="password" NAME="Password2"/> |
| </FIELDSET> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/legend.xhtml |
|---|
| 0,0 → 1,23 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - LEGEND</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <fieldset> |
| <legend accesskey="b" align="top">Enter Password1:</legend> |
| <input id="input1" type="password" name="Password1"/> |
| </fieldset> |
| </form> |
| <fieldset> |
| <legend accesskey="c" align="bottom">Enter Password2:</legend> |
| <input id="input2" type="password" name="Password2"/> |
| </fieldset> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/legend.xml |
|---|
| 0,0 → 1,23 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - LEGEND</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <fieldset> |
| <legend accesskey="b" align="top">Enter Password1:</legend> |
| <input id="input1" type="password" name="Password1"/> |
| </fieldset> |
| </form> |
| <fieldset> |
| <legend accesskey="c" align="bottom">Enter Password2:</legend> |
| <input id="input2" type="password" name="Password2"/> |
| </fieldset> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/li.html |
|---|
| 0,0 → 1,23 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - LI</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <OL> |
| <LI TYPE="square" VALUE="2">EMP0001 |
| <UL> |
| <LI>Margaret Martin |
| <DL> |
| <DD>Accountant</DD> |
| <DD>56,000</DD> |
| <DD>Female</DD> |
| </DL> |
| </LI> |
| </UL> |
| </LI> |
| </OL> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/li.xhtml |
|---|
| 0,0 → 1,25 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - LI</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <ol> |
| <li type="square" value="2">EMP0001 |
| <ul> |
| <li>Margaret Martin |
| <dl> |
| <dd>Accountant</dd> |
| <dd>56,000</dd> |
| <dd>Female</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| </ol> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/li.xml |
|---|
| 0,0 → 1,25 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - LI</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <ol> |
| <li type="square" value="2">EMP0001 |
| <ul> |
| <li>Margaret Martin |
| <dl> |
| <dd>Accountant</dd> |
| <dd>56,000</dd> |
| <dd>Female</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| </ol> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/link.html |
|---|
| 0,0 → 1,15 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - LINK</TITLE> |
| <LINK CHARSET="Latin-1" HREF="./files/glossary.html" HREFLANG="en" MEDIA="screen" REL="Glossary" TYPE="text/html"> |
| <LINK CHARSET="Latin-1" HREF="./files/style1.css" HREFLANG="en" MEDIA="screen" REV="stylesheet" TYPE="text/css"> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <BR> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/link.xhtml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - LINK</title> |
| <link charset="Latin-1" href="./files/glossary.html" hreflang="en" media="screen" rel="Glossary" type="text/html"/> |
| <link charset="Latin-1" href="./files/style1.css" hreflang="en" media="screen" rev="stylesheet" type="text/css"/> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <br/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/link.xml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - LINK</title> |
| <link charset="Latin-1" href="./files/glossary.html" hreflang="en" media="screen" rel="Glossary" type="text/html"/> |
| <link charset="Latin-1" href="./files/style1.css" hreflang="en" media="screen" rev="stylesheet" type="text/css"/> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <br/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/link2.html |
|---|
| 0,0 → 1,15 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" |
| "http://www.w3.org/TR/html4/loose.dtd"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - LINK</TITLE> |
| <LINK CHARSET="Latin-1" TARGET="dynamic" HREF="./files/glossary.html" HREFLANG="en" MEDIA="screen" REL="Glossary" TYPE="text/html"> |
| <LINK CHARSET="Latin-1" HREF="./files/style1.css" HREFLANG="en" MEDIA="screen" REV="stylesheet" TYPE="text/css"> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <BR> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/link2.xhtml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - LINK</title> |
| <link charset="Latin-1" target="dynamic" href="./files/glossary.html" hreflang="en" media="screen" rel="Glossary" type="text/html"/> |
| <link charset="Latin-1" href="./files/style1.css" hreflang="en" media="screen" rev="stylesheet" type="text/css"/> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <br/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/link2.xml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - LINK</title> |
| <link charset="Latin-1" target="dynamic" href="./files/glossary.html" hreflang="en" media="screen" rel="Glossary" type="text/html"/> |
| <link charset="Latin-1" href="./files/style1.css" hreflang="en" media="screen" rev="stylesheet" type="text/css"/> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <br/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/map.html |
|---|
| 0,0 → 1,16 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - MAP</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <MAP NAME="mapid" ID="mapid"> |
| <AREA HREF="./files/dletter1.html" TITLE="Domain1" ALT="Domain1"> |
| <AREA HREF="./files/dletter2.html" TITLE="Domain2" ALT="Domain2"> |
| <AREA HREF="./files/dletter3.html" TITLE="Domain3" ALT="Domain3"> |
| </MAP> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/map.xhtml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - MAP</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <map name="mapid" id="mapid"> |
| <area href="./files/dletter1.html" title="Domain1" alt="Domain1"/> |
| <area href="./files/dletter2.html" title="Domain2" alt="Domain2"/> |
| <area href="./files/dletter3.html" title="Domain3" alt="Domain3"/> |
| </map> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/map.xml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - MAP</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <map name="mapid" id="mapid"> |
| <area href="./files/dletter1.html" title="Domain1" alt="Domain1"/> |
| <area href="./files/dletter2.html" title="Domain2" alt="Domain2"/> |
| <area href="./files/dletter3.html" title="Domain3" alt="Domain3"/> |
| </map> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/menu.html |
|---|
| 0,0 → 1,15 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - MENU</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <MENU COMPACT="COMPACT"> |
| <LI>Interview</LI> |
| <LI>Paperwork</LI> |
| <LI>Give start date</LI> |
| </MENU> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/menu.xhtml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - MENU</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <menu compact="compact"> |
| <li>Interview</li> |
| <li>Paperwork</li> |
| <li>Give start date</li> |
| </menu> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/menu.xml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - MENU</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <menu compact="compact"> |
| <li>Interview</li> |
| <li>Paperwork</li> |
| <li>Give start date</li> |
| </menu> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/meta.html |
|---|
| 0,0 → 1,13 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD> |
| <META NAME="Meta-Name" HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8" SCHEME="NIST"> |
| <TITLE>NIST DOM HTML Test - META</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <BR/> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/meta.xhtml |
|---|
| 0,0 → 1,16 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <meta name="Meta-Name" http-equiv="Content-Type" content="text/html; CHARSET=utf-8" scheme="NIST"/> |
| <title>NIST DOM HTML Test - META</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <br/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/meta.xml |
|---|
| 0,0 → 1,16 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <meta name="Meta-Name" http-equiv="Content-Type" content="text/html; CHARSET=utf-8" scheme="NIST"/> |
| <title>NIST DOM HTML Test - META</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <br/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/mod.html |
|---|
| 0,0 → 1,15 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - MOD</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <INS CITE="./files/ins-reasons.html" DATETIME="January 1, 2002">The INS element is used to indicate that a section of a document had been inserted.</INS> |
| <BR/> |
| <DEL CITE="./files/del-reasons.html" DATETIME="January 2, 2002">The DEL element is used to indicate that a section of a document had been removed.</DEL> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/mod.xhtml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - MOD</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <ins cite="./files/ins-reasons.html" datetime="January 1, 2002">The INS element is used to indicate that a section of a document had been inserted.</ins> |
| <br/> |
| <del cite="./files/del-reasons.html" datetime="January 2, 2002">The DEL element is used to indicate that a section of a document had been removed.</del> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/mod.xml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - MOD</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <ins cite="./files/ins-reasons.html" datetime="January 1, 2002">The INS element is used to indicate that a section of a document had been inserted.</ins> |
| <br/> |
| <del cite="./files/del-reasons.html" datetime="January 2, 2002">The DEL element is used to indicate that a section of a document had been removed.</del> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/object.html |
|---|
| 0,0 → 1,18 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - OBJECT</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <OBJECT ALIGN="middle" ARCHIVE="" BORDER="0" CODEBASE="http://www.w3.org/DOM/" DATA="./pix/logo.gif" HEIGHT="60" HSPACE="0" STANDBY="Loading Image ..." TABINDEX="0" TYPE="image/gif" USEMAP="#DivLogo-map" VSPACE="0" WIDTH="550"></OBJECT> |
| </P> |
| <FORM NAME="OBJECT2" ACTION="./files/getData.pl" METHOD="post"> |
| <P> |
| <OBJECT DECLARE="declare" NAME="OBJECT2" CODETYPE="image/gif"></OBJECT> |
| </P> |
| </FORM> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/object.xhtml |
|---|
| 0,0 → 1,20 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OBJECT</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <object align="middle" archive="" border="0" codebase="http://www.w3.org/DOM/" data="./pix/logo.gif" height="60" hspace="0" standby="Loading Image ..." tabindex="0" type="image/gif" usemap="#DivLogo-map" vspace="0" width="550"></object> |
| </p> |
| <form name="OBJECT2" action="./files/getData.pl" method="post"> |
| <p> |
| <object declare="declare" name="OBJECT2" codetype="image/gif"></object> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/object.xml |
|---|
| 0,0 → 1,20 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OBJECT</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <object align="middle" archive="" border="0" codebase="http://xw2k.sdct.itl.nist.gov/brady/dom/" data="./pix/logo.gif" height="60" hspace="0" standby="Loading Image ..." tabindex="0" type="image/gif" usemap="#DivLogo-map" vspace="0" width="550"></object> |
| </p> |
| <form name="OBJECT2" action="./files/getData.pl" method="post"> |
| <p> |
| <object declare="declare" name="OBJECT2" codetype="image/gif"></object> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/object2.html |
|---|
| 0,0 → 1,17 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - OBJECT</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <OBJECT ALIGN="middle" ARCHIVE="" BORDER="0" CODEBASE="http://www.w3.org/DOM/" DATA="./pix/logo.gif" HEIGHT="60" HSPACE="0" STANDBY="Loading Image ..." TABINDEX="0" TYPE="image/gif" USEMAP="#DivLogo-map" VSPACE="0" WIDTH="550"></OBJECT> |
| </P> |
| <FORM ID="object2" ACTION="./files/getData.pl" METHOD="post"> |
| <P> |
| <OBJECT DECLARE="declare" NAME="OBJECT2" CODETYPE="image/gif"></OBJECT> |
| </P> |
| </FORM> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/object2.xhtml |
|---|
| 0,0 → 1,20 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OBJECT</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <object align="middle" archive="" border="0" codebase="http://www.w3.org/DOM/" data="./pix/logo.gif" height="60" hspace="0" standby="Loading Image ..." tabindex="0" type="image/gif" usemap="#DivLogo-map" vspace="0" width="550"></object> |
| </p> |
| <form id="object2" action="./files/getData.pl" method="post"> |
| <p> |
| <object declare="declare" name="OBJECT2" codetype="image/gif"></object> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/object2.xml |
|---|
| 0,0 → 1,20 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OBJECT</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <object align="middle" archive="" border="0" codebase="http://xw2k.sdct.itl.nist.gov/brady/dom/" data="./pix/logo.gif" height="60" hspace="0" standby="Loading Image ..." tabindex="0" type="image/gif" usemap="#DivLogo-map" vspace="0" width="550"></object> |
| </p> |
| <form id="object2" action="./files/getData.pl" method="post"> |
| <p> |
| <object declare="declare" name="OBJECT2" codetype="image/gif"></object> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/olist.html |
|---|
| 0,0 → 1,32 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - OLIST</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <OL COMPACT="compact" START="1" TYPE="1"> |
| <LI>EMP0001 |
| <UL> |
| <LI>Margaret Martin |
| <DL> |
| <DD>Accountant</DD> |
| <DD>56,000</DD> |
| </DL> |
| </LI> |
| </UL> |
| </LI> |
| <LI>EMP0002 |
| <UL> |
| <LI>Martha Raynolds |
| <DL> |
| <DD>Secretary</DD> |
| <DD>35,000</DD> |
| </DL> |
| </LI> |
| </UL> |
| </LI> |
| </OL> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/olist.xhtml |
|---|
| 0,0 → 1,34 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OLIST</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <ol compact="compact" start="1" type="1"> |
| <li>EMP0001 |
| <ul> |
| <li>Margaret Martin |
| <dl> |
| <dd>Accountant</dd> |
| <dd>56,000</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| <li>EMP0002 |
| <ul> |
| <li>Martha Raynolds |
| <dl> |
| <dd>Secretary</dd> |
| <dd>35,000</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| </ol> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/olist.xml |
|---|
| 0,0 → 1,34 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OLIST</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <ol compact="compact" start="1" type="1"> |
| <li>EMP0001 |
| <ul> |
| <li>Margaret Martin |
| <dl> |
| <dd>Accountant</dd> |
| <dd>56,000</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| <li>EMP0002 |
| <ul> |
| <li>Martha Raynolds |
| <dl> |
| <dd>Secretary</dd> |
| <dd>35,000</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| </ol> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/optgroup.html |
|---|
| 0,0 → 1,25 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - OPTGROUP</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="Form1" ACTION="test.pl" METHOD="post"> |
| <P> |
| <SELECT NAME="select2"> |
| <OPTGROUP LABEL="Regular Employees"> |
| <OPTION>EMP0001</OPTION> |
| <OPTION>EMP0002</OPTION> |
| <OPTION>EMP0003A</OPTION> |
| </OPTGROUP> |
| <OPTGROUP DISABLED="disabled" LABEL="Temporary Employees"> |
| <OPTION>EMP0004</OPTION> |
| <OPTION>EMP0005</OPTION> |
| </OPTGROUP> |
| </SELECT> |
| </P> |
| </FORM> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/optgroup.xhtml |
|---|
| 0,0 → 1,27 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OPTGROUP</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="Form1" action="test.pl" method="post"> |
| <p> |
| <select name="select2"> |
| <optgroup label="Regular Employees"> |
| <option>EMP0001</option> |
| <option>EMP0002</option> |
| <option>EMP0003A</option> |
| </optgroup> |
| <optgroup disabled="disabled" label="Temporary Employees"> |
| <option>EMP0004</option> |
| <option>EMP0005</option> |
| </optgroup> |
| </select> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/optgroup.xml |
|---|
| 0,0 → 1,27 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OPTGROUP</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="Form1" action="test.pl" method="post"> |
| <p> |
| <select name="select2"> |
| <optgroup label="Regular Employees"> |
| <option>EMP0001</option> |
| <option>EMP0002</option> |
| <option>EMP0003A</option> |
| </optgroup> |
| <optgroup disabled="disabled" label="Temporary Employees"> |
| <option>EMP0004</option> |
| <option>EMP0005</option> |
| </optgroup> |
| </select> |
| </p> |
| </form> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/option.html |
|---|
| 0,0 → 1,36 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - OPTION</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form1" NAME="form1" ACTION="./files/getData.pl" METHOD="post"> |
| <P> |
| <SELECT ID="selectId" DIR="ltr" TABINDEX="7" NAME="select1" MULTIPLE="multiple" SIZE="1"> |
| <OPTION SELECTED="selected" value="10001">EMP10001</OPTION> |
| <OPTION LABEL="l1">EMP10002</OPTION> |
| <OPTION>EMP10003</OPTION> |
| <OPTION>EMP10004</OPTION> |
| <OPTION>EMP10005</OPTION> |
| </SELECT> |
| </P> |
| </FORM> |
| <P> |
| <SELECT NAME="select2" disabled="disabled"> |
| <OPTION>EMP20001</OPTION> |
| <OPTION>EMP20002</OPTION> |
| <OPTION>EMP20003</OPTION> |
| <OPTION>EMP20004</OPTION> |
| <OPTION DISABLED="disabled">EMP20005</OPTION> |
| </SELECT> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/option.xhtml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OPTION</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <select id="selectId" dir="ltr" tabindex="7" name="select1" multiple="multiple" size="1"> |
| <option selected="selected" value="10001">EMP10001</option> |
| <option label="l1">EMP10002</option> |
| <option>EMP10003</option> |
| <option>EMP10004</option> |
| <option>EMP10005</option> |
| </select> |
| </p> |
| </form> |
| <p> |
| <select name="select2" disabled="disabled"> |
| <option>EMP20001</option> |
| <option>EMP20002</option> |
| <option>EMP20003</option> |
| <option>EMP20004</option> |
| <option disabled="disabled">EMP20005</option> |
| </select> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/option.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OPTION</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <select id="selectId" dir="ltr" tabindex="7" name="select1" multiple="multiple" size="1"> |
| <option selected="selected" value="10001">EMP10001</option> |
| <option label="l1">EMP10002</option> |
| <option>EMP10003</option> |
| <option>EMP10004</option> |
| <option>EMP10005</option> |
| </select> |
| </p> |
| </form> |
| <p> |
| <select name="select2" disabled="disabled"> |
| <option>EMP20001</option> |
| <option>EMP20002</option> |
| <option>EMP20003</option> |
| <option>EMP20004</option> |
| <option disabled="disabled">EMP20005</option> |
| </select> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/paragraph.html |
|---|
| 0,0 → 1,13 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - PARAGRAPH</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P ALIGN="center"> |
| TEXT |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/paragraph.xhtml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - PARAGRAPH</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p align="center"> |
| TEXT |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/paragraph.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - PARAGRAPH</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p align="center"> |
| TEXT |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/param.html |
|---|
| 0,0 → 1,14 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - PARAM</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <OBJECT> |
| <PARAM NAME="image3" TYPE="image/gif" VALUE="image/file.gif" VALUETYPE="ref"> |
| </OBJECT> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/param.xhtml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - PARAM</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <object> |
| <param name="image3" type="image/gif" value="image/file.gif" valuetype="ref"/> |
| </object> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/param.xml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - PARAM</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <object> |
| <param name="image3" type="image/gif" value="image/file.gif" valuetype="ref"/> |
| </object> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/pre.html |
|---|
| 0,0 → 1,17 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - PRE</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <PRE WIDTH="277">The PRE is used to indicate pre-formatted text. Visual agents may: |
| leave white space intact. |
| May render text with a fixed-pitch font. |
| May disable automatic word wrap. |
| Must not disable bidirectional processing. |
| </PRE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/pre.xhtml |
|---|
| 0,0 → 1,19 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - PRE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <pre>The PRE is used to indicate pre-formatted text. Visual agents may: |
| leave white space intact. |
| May render text with a fixed-pitch font. |
| May disable automatic word wrap. |
| Must not disable bidirectional processing. |
| </pre> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/pre.xml |
|---|
| 0,0 → 1,19 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - PRE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <pre>The PRE is used to indicate pre-formatted text. Visual agents may: |
| leave white space intact. |
| May render text with a fixed-pitch font. |
| May disable automatic word wrap. |
| Must not disable bidirectional processing. |
| </pre> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/quote.html |
|---|
| 0,0 → 1,16 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - QUOTE</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <Q CITE="./files/Q.html">The Q element is intended for short quotations</Q> |
| </P> |
| <BLOCKQUOTE CITE="./files/BLOCKQUOTE.html"> |
| <P>The BLOCKQUOTE element is used for long quotations.</P> |
| </BLOCKQUOTE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/quote.xhtml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - QUOTE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <q cite="./files/Q.html">The Q element is intended for short quotations</q> |
| </p> |
| <blockquote cite="./files/BLOCKQUOTE.html"> |
| <p>The BLOCKQUOTE element is used for long quotations.</p> |
| </blockquote> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/quote.xml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - QUOTE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <q cite="./files/Q.html">The Q element is intended for short quotations</q> |
| </p> |
| <blockquote cite="./files/BLOCKQUOTE.html"> |
| <p>The BLOCKQUOTE element is used for long quotations.</p> |
| </blockquote> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/right.png |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/script.html |
|---|
| 0,0 → 1,11 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - SCRIPT</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <SCRIPT CHARSET="US-ASCII" TYPE="text/javaScript" DEFER="defer" SRC="./files/script1.js">var a=2;</SCRIPT> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/script.xhtml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - SCRIPT</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <script charset="US-ASCII" type="text/javaScript" defer="defer" src="./files/script1.js">var a=2;</script> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/script.xml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - SCRIPT</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <script charset="US-ASCII" type="text/javaScript" defer="defer" src="./files/script1.js">var a=2;</script> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/select.html |
|---|
| 0,0 → 1,44 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - SELECT</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form1" ACTION="./files/getData.pl" METHOD="post"> |
| <P> |
| <SELECT ID="selectId" DIR="ltr" TABINDEX="7" NAME="select1" MULTIPLE="multiple" SIZE="1"> |
| <OPTION SELECTED="selected" value="EMP1">EMP10001</OPTION> |
| <OPTION>EMP10002</OPTION> |
| <OPTION>EMP10003</OPTION> |
| <OPTION>EMP10004</OPTION> |
| <OPTION>EMP10005</OPTION> |
| </SELECT> |
| </P> |
| </FORM> |
| <P> |
| <SELECT NAME="select2"> |
| <OPTION>EMP20001</OPTION> |
| <OPTION>EMP20002</OPTION> |
| <OPTION>EMP20003</OPTION> |
| <OPTION>EMP20004</OPTION> |
| <OPTION>EMP20005</OPTION> |
| </SELECT> |
| </P> |
| <P> |
| <SELECT NAME="select3" DISABLED="disabled" TABINDEX="1"> |
| <OPTION>EMP30001</OPTION> |
| <OPTION>EMP30002</OPTION> |
| <OPTION>EMP30003</OPTION> |
| <OPTION>EMP30004</OPTION> |
| <OPTION>EMP30005</OPTION> |
| </SELECT> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/select.xhtml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - SELECT</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <select id="selectId" dir="ltr" tabindex="7" name="select1" multiple="multiple" size="1"> |
| <option selected="selected" value="EMP1">EMP10001</option> |
| <option>EMP10002</option> |
| <option>EMP10003</option> |
| <option>EMP10004</option> |
| <option>EMP10005</option> |
| </select> |
| </p> |
| </form> |
| <p> |
| <select name="select2"> |
| <option>EMP20001</option> |
| <option>EMP20002</option> |
| <option>EMP20003</option> |
| <option>EMP20004</option> |
| <option>EMP20005</option> |
| </select> |
| </p> |
| <p> |
| <select name="select3" disabled="disabled" tabindex="1"> |
| <option>EMP30001</option> |
| <option>EMP30002</option> |
| <option>EMP30003</option> |
| <option>EMP30004</option> |
| <option>EMP30005</option> |
| </select> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/select.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - SELECT</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <select id="selectId" dir="ltr" tabindex="7" name="select1" multiple="multiple" size="1"> |
| <option selected="selected" value="EMP1">EMP10001</option> |
| <option>EMP10002</option> |
| <option>EMP10003</option> |
| <option>EMP10004</option> |
| <option>EMP10005</option> |
| </select> |
| </p> |
| </form> |
| <p> |
| <select name="select2"> |
| <option>EMP20001</option> |
| <option>EMP20002</option> |
| <option>EMP20003</option> |
| <option>EMP20004</option> |
| <option>EMP20005</option> |
| </select> |
| </p> |
| <p> |
| <select name="select3" disabled="disabled" tabindex="1"> |
| <option>EMP30001</option> |
| <option>EMP30002</option> |
| <option>EMP30003</option> |
| <option>EMP30004</option> |
| <option>EMP30005</option> |
| </select> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/style.html |
|---|
| 0,0 → 1,12 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <STYLE MEDIA="screen" type="text/css"></STYLE> |
| <TITLE>NIST DOM HTML Test - STYLE</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P>Hello, World.</P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/style.xhtml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <style media="screen" type="text/css"></style> |
| <title>NIST DOM HTML Test - BR</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>Hello, World.</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/style.xml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <style media="screen" type="text/css"></style> |
| <title>NIST DOM HTML Test - BR</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>Hello, World.</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/table.html |
|---|
| 0,0 → 1,78 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - TABLE</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <TABLE ALIGN="center" SUMMARY="Table 1"> |
| <TR> |
| <TH>Id</TH> |
| <TH>Name</TH> |
| <TH>Position</TH> |
| <TH>Salary</TH> |
| </TR> |
| </TABLE> |
| <TABLE ID="table-1" ALIGN="center" BORDER="4" BGCOLOR="#ff0000" FRAME="border" CELLPADDING="2" CELLSPACING="2" SUMMARY="HTML Control Table" RULES="all" WIDTH="680"> |
| <CAPTION ALIGN="top">Table Caption</CAPTION> |
| <THEAD ALIGN="center" VALIGN="middle"> |
| <TR ALIGN="center" BGCOLOR="#00FFFF" VALIGN="middle"> |
| <TH ID="header-1">Employee Id</TH> |
| <TH ID="header-2" ABBR="maiden" AXIS="center" ALIGN="center" BGCOLOR="#00FFFF" COLSPAN="1" HEIGHT="50" NOWRAP="nowrap" ROWSPAN="1" SCOPE="col" HEADERS="header-1" VALIGN="middle" WIDTH="100">Employee Name</TH> |
| <TH>Position</TH> |
| <TH>Salary</TH> |
| <TH>Gender</TH> |
| <TH>Address</TH> |
| </TR> |
| </THEAD> |
| <TFOOT ALIGN="center" VALIGN="middle"> |
| <TR> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| </TR> |
| </TFOOT> |
| <TBODY ALIGN="center" VALIGN="middle"> |
| <TR> |
| <TD AXIS="center" ID="Table-3" ABBR="maiden2" ALIGN="center" BGCOLOR="#FF0000" COLSPAN="1" HEIGHT="50" NOWRAP="nowrap" ROWSPAN="1" SCOPE="col" HEADERS="header-2" VALIGN="middle" WIDTH="175">EMP0001</TD> |
| <TD HEADERS="header-2">Margaret Martin</TD> |
| <TD>Accountant</TD> |
| <TD>56,000</TD> |
| <TD>Female</TD> |
| <TD>1230 North Ave. Dallas, Texas 98551</TD> |
| </TR> |
| <TR> |
| <TD>EMP0002</TD> |
| <TD>Martha Raynolds</TD> |
| <TD>Secretary</TD> |
| <TD>35,000</TD> |
| <TD>Female</TD> |
| <TD>1900 Dallas Road Dallas, Texas 98554</TD> |
| </TR> |
| </TBODY> |
| </TABLE> |
| <TABLE SUMMARY="Table 3"> |
| <TBODY> |
| <TR> |
| <TD> |
| </TD> |
| </TR> |
| </TBODY> |
| <TBODY> |
| <TR> |
| <TD> |
| </TD> |
| </TR> |
| </TBODY> |
| <TBODY> |
| <TR> |
| <TD> |
| </TD> |
| </TR> |
| </TBODY> |
| </TABLE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/table.xhtml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table align="center" summary="Table 1"> |
| <tr> |
| <th>Id</th> |
| <th>Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| </table> |
| <table id="table-1" align="center" border="4" bgcolor="#ff0000" frame="border" cellpadding="2" cellspacing="2" summary="HTML Control Table" rules="all" width="680"> |
| <caption align="top">Table Caption</caption> |
| <thead align="center" valign="middle"> |
| <tr align="center" bgcolor="#00FFFF" valign="middle"> |
| <th id="header-1">Employee Id</th> |
| <th id="header-2" abbr="maiden" axis="center" align="center" bgcolor="#00FFFF" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-1" valign="middle" width="100">Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| <th>Gender</th> |
| <th>Address</th> |
| </tr> |
| </thead> |
| <tfoot align="center" valign="middle"> |
| <tr> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| </tr> |
| </tfoot> |
| <tbody align="center" valign="middle"> |
| <tr> |
| <td axis="center" id="Table-3" abbr="maiden2" align="center" bgcolor="#FF0000" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-2" valign="middle" width="175">EMP0001</td> |
| <td headers="header-2">Margaret Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| <td>Female</td> |
| <td>1230 North Ave. Dallas, Texas 98551</td> |
| </tr> |
| <tr> |
| <td>EMP0002</td> |
| <td>Martha Raynolds</td> |
| <td>Secretary</td> |
| <td>35,000</td> |
| <td>Female</td> |
| <td>1900 Dallas Road Dallas, Texas 98554</td> |
| </tr> |
| </tbody> |
| </table> |
| <table summary="Table 3"> |
| <tbody> |
| <tr> |
| <td> |
| </td> |
| </tr> |
| </tbody> |
| <tbody> |
| <tr> |
| <td> |
| </td> |
| </tr> |
| </tbody> |
| <tbody> |
| <tr> |
| <td> |
| </td> |
| </tr> |
| </tbody> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/table.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table align="center" summary="Table 1"> |
| <tr> |
| <th>Id</th> |
| <th>Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| </table> |
| <table id="table-1" align="center" border="4" bgcolor="#ff0000" frame="border" cellpadding="2" cellspacing="2" summary="HTML Control Table" rules="all" width="680"> |
| <caption align="top">Table Caption</caption> |
| <thead align="center" valign="middle"> |
| <tr align="center" bgcolor="#00FFFF" valign="middle"> |
| <th id="header-1">Employee Id</th> |
| <th id="header-2" abbr="maiden" axis="center" align="center" bgcolor="#00FFFF" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-1" valign="middle" width="100">Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| <th>Gender</th> |
| <th>Address</th> |
| </tr> |
| </thead> |
| <tfoot align="center" valign="middle"> |
| <tr> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| </tr> |
| </tfoot> |
| <tbody align="center" valign="middle"> |
| <tr> |
| <td axis="center" id="Table-3" abbr="maiden2" align="center" bgcolor="#FF0000" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-2" valign="middle" width="175">EMP0001</td> |
| <td headers="header-2">Margaret Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| <td>Female</td> |
| <td>1230 North Ave. Dallas, Texas 98551</td> |
| </tr> |
| <tr> |
| <td>EMP0002</td> |
| <td>Martha Raynolds</td> |
| <td>Secretary</td> |
| <td>35,000</td> |
| <td>Female</td> |
| <td>1900 Dallas Road Dallas, Texas 98554</td> |
| </tr> |
| </tbody> |
| </table> |
| <table summary="Table 3"> |
| <tbody> |
| <tr> |
| <td> |
| </td> |
| </tr> |
| </tbody> |
| <tbody> |
| <tr> |
| <td> |
| </td> |
| </tr> |
| </tbody> |
| <tbody> |
| <tr> |
| <td> |
| </td> |
| </tr> |
| </tbody> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/table1.html |
|---|
| 0,0 → 1,12 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - TABLE</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <TABLE SUMMARY="Empty Table"> |
| <tr><td>HTML can't abide empty table</td></tr> |
| </TABLE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/table1.xhtml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table summary="Empty Table"> |
| <tr><td>XHTML can't abide empty table</td></tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/table1.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table summary="Empty Table"> |
| <tr><td>XHTML can't abide empty table</td></tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablecaption.html |
|---|
| 0,0 → 1,25 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - TABLECAPTION</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <TABLE SUMMARY="Table Summary"> |
| <CAPTION ALIGN="top">CAPTION 1</CAPTION> |
| <TR> |
| <TH>Employee Id</TH> |
| <TH>Employee Name</TH> |
| <TH>Position</TH> |
| <TH>Salary</TH> |
| </TR> |
| </TABLE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablecaption.xhtml |
|---|
| 0,0 → 1,21 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - BR</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table summary="Table 1"> |
| <caption align="top">CAPTION 1</caption> |
| <tr> |
| <th>Employee Id</th> |
| <th>Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablecaption.xml |
|---|
| 0,0 → 1,21 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - BR</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table summary="Table 1"> |
| <caption align="top">CAPTION 1</caption> |
| <tr> |
| <th>Employee Id</th> |
| <th>Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablecell.html |
|---|
| 0,0 → 1,23 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - TABLECELL</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <TABLE SUMMARY="Table Summary"> |
| <TR> |
| <TH ID="header-1">Employee Id</TH> |
| <TH ID="header-2" ABBR="hd1" AXIS="center" ALIGN="center" BGCOLOR="#00FFFF" CHAR=":" CHAROFF="1" COLSPAN="1" HEIGHT="50" NOWRAP="nowrap" ROWSPAN="1" SCOPE="col" HEADERS="header-1" VALIGN="middle" WIDTH="170">Employee Name</TH> |
| <TH>Position</TH> |
| <TH>Salary</TH> |
| </TR> |
| <TR> |
| <TD ID="header-3">EMP0001</TD> |
| <TD ID="header-4" ABBR="hd2" AXIS="center" ALIGN="center" BGCOLOR="#FF0000" CHAR=":" CHAROFF="1" COLSPAN="1" HEIGHT="50" NOWRAP="nowrap" ROWSPAN="1" SCOPE="col" HEADERS="header-3" VALIGN="middle" WIDTH="175">Margaret Martin</TD> |
| <TD>Accountant</TD> |
| <TD>56,000</TD> |
| </TR> |
| </TABLE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablecell.xhtml |
|---|
| 0,0 → 1,26 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLECELL</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table summary="Table 1"> |
| <tr> |
| <th id="header-1">Employee Id</th> |
| <th id="header-2" abbr="hd1" axis="center" align="center" bgcolor="#00FFFF" char=":" charoff="1" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-1" valign="middle" width="170">Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| <tr> |
| <td id="header-3">EMP0001</td> |
| <td id="header-4" abbr="hd2" axis="center" align="center" bgcolor="#FF0000" char=":" charoff="1" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-3" valign="middle" width="175">Margaret Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablecell.xml |
|---|
| 0,0 → 1,26 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLECELL</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table summary="Table 1"> |
| <tr> |
| <th id="header-1">Employee Id</th> |
| <th id="header-2" abbr="hd1" axis="center" align="center" bgcolor="#00FFFF" char=":" charoff="1" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-1" valign="middle" width="170">Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| <tr> |
| <td id="header-3">EMP0001</td> |
| <td id="header-4" abbr="hd2" axis="center" align="center" bgcolor="#FF0000" char=":" charoff="1" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-3" valign="middle" width="175">Margaret Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablecol.html |
|---|
| 0,0 → 1,35 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - TABLECOL</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <TABLE SUMMARY="Table Summary"> |
| <COLGROUP VALIGN="middle" SPAN="2" ALIGN="center" WIDTH="20" CHAR="$" CHAROFF="15"> |
| <COL VALIGN="middle" SPAN="1" ALIGN="center" WIDTH="20" CHAR="*" CHAROFF="20"> |
| </COLGROUP> |
| <TR> |
| <TH>Id</TH> |
| <TH>Name</TH> |
| <TH>Position</TH> |
| <TH>Salary</TH> |
| </TR> |
| <TR> |
| <TD>EMP0001</TD> |
| <TD>Martin</TD> |
| <TD>Accountant</TD> |
| <TD>56,000</TD> |
| </TR> |
| </TABLE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablecol.xhtml |
|---|
| 0,0 → 1,29 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLECOL</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table summary="Table 1"> |
| <colgroup valign="middle" span="2" align="center" width="20" char="$" charoff="15"> |
| <col valign="middle" span="1" align="center" width="20" char="*" charoff="20"/> |
| </colgroup> |
| <tr> |
| <th>Id</th> |
| <th>Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| <tr> |
| <td>EMP0001</td> |
| <td>Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablecol.xml |
|---|
| 0,0 → 1,29 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLECOL</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table summary="Table 1"> |
| <colgroup valign="middle" span="2" align="center" width="20" char="$" charoff="15"> |
| <col valign="middle" span="1" align="center" width="20" char="*" charoff="20"/> |
| </colgroup> |
| <tr> |
| <th>Id</th> |
| <th>Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| <tr> |
| <td>EMP0001</td> |
| <td>Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| </tr> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablerow.html |
|---|
| 0,0 → 1,59 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - TABLEROW</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <TABLE ALIGN="center" SUMMARY="Table 1"> |
| <TR> |
| <TH>Id</TH> |
| <TH>Name</TH> |
| <TH>Position</TH> |
| <TH>Salary</TH> |
| </TR> |
| </TABLE> |
| <TABLE ID="table-1" ALIGN="center" BORDER="4" BGCOLOR="#ff0000" FRAME="border" CELLPADDING="2" CELLSPACING="2" SUMMARY="HTML Control Table" RULES="all" WIDTH="680"> |
| <CAPTION ALIGN="top">Table Caption</CAPTION> |
| <THEAD ALIGN="center" VALIGN="middle"> |
| <TR ALIGN="center" BGCOLOR="#00FFFF" VALIGN="middle" CHAR="*" CHAROFF="1"> |
| <TH ID="header-1">Employee Id</TH> |
| <TH ID="header-2" ABBR="maiden" AXIS="center" ALIGN="center" BGCOLOR="#00FFFF" COLSPAN="1" HEIGHT="50" NOWRAP="nowrap" ROWSPAN="1" SCOPE="col" HEADERS="header-1" VALIGN="middle" WIDTH="100">Employee Name</TH> |
| <TH>Position</TH> |
| <TH>Salary</TH> |
| <TH>Gender</TH> |
| <TH>Address</TH> |
| </TR> |
| </THEAD> |
| <TFOOT ALIGN="center" VALIGN="middle"> |
| <TR> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| </TR> |
| </TFOOT> |
| <TBODY ALIGN="center" VALIGN="middle"> |
| <TR> |
| <TD AXIS="center" ID="Table-3" ABBR="maiden2" ALIGN="center" BGCOLOR="#FF0000" COLSPAN="1" HEIGHT="50" NOWRAP="nowrap" ROWSPAN="1" SCOPE="col" HEADERS="header-2" VALIGN="middle" WIDTH="175">EMP0001</TD> |
| <TD HEADERS="header-2">Margaret Martin</TD> |
| <TD>Accountant</TD> |
| <TD>56,000</TD> |
| <TD>Female</TD> |
| <TD>1230 North Ave. Dallas, Texas 98551</TD> |
| </TR> |
| <TR> |
| <TD>EMP0002</TD> |
| <TD>Martha Raynolds</TD> |
| <TD>Secretary</TD> |
| <TD>35,000</TD> |
| <TD>Female</TD> |
| <TD>1900 Dallas Road Dallas, Texas 98554</TD> |
| </TR> |
| </TBODY> |
| </TABLE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablerow.xhtml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table align="center" summary="Table 1"> |
| <tr> |
| <th>Id</th> |
| <th>Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| </table> |
| <table id="table-1" align="center" border="4" bgcolor="#ff0000" frame="border" cellpadding="2" cellspacing="2" summary="HTML Control Table" rules="all" width="680"> |
| <caption align="top">Table Caption</caption> |
| <thead align="center" valign="middle"> |
| <tr align="center" bgcolor="#00FFFF" valign="middle" char="*" charoff="1"> |
| <th id="header-1">Employee Id</th> |
| <th id="header-2" abbr="maiden" axis="center" align="center" bgcolor="#00FFFF" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-1" valign="middle" width="100">Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| <th>Gender</th> |
| <th>Address</th> |
| </tr> |
| </thead> |
| <tfoot align="center" valign="middle"> |
| <tr> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| </tr> |
| </tfoot> |
| <tbody align="center" valign="middle"> |
| <tr> |
| <td axis="center" id="Table-3" abbr="maiden2" align="center" bgcolor="#FF0000" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-2" valign="middle" width="175">EMP0001</td> |
| <td headers="header-2">Margaret Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| <td>Female</td> |
| <td>1230 North Ave. Dallas, Texas 98551</td> |
| </tr> |
| <tr> |
| <td>EMP0002</td> |
| <td>Martha Raynolds</td> |
| <td>Secretary</td> |
| <td>35,000</td> |
| <td>Female</td> |
| <td>1900 Dallas Road Dallas, Texas 98554</td> |
| </tr> |
| </tbody> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablerow.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table align="center" summary="Table 1"> |
| <tr> |
| <th>Id</th> |
| <th>Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| </table> |
| <table id="table-1" align="center" border="4" bgcolor="#ff0000" frame="border" cellpadding="2" cellspacing="2" summary="HTML Control Table" rules="all" width="680"> |
| <caption align="top">Table Caption</caption> |
| <thead align="center" valign="middle"> |
| <tr align="center" bgcolor="#00FFFF" valign="middle" char="*" charoff="1"> |
| <th id="header-1">Employee Id</th> |
| <th id="header-2" abbr="maiden" axis="center" align="center" bgcolor="#00FFFF" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-1" valign="middle" width="100">Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| <th>Gender</th> |
| <th>Address</th> |
| </tr> |
| </thead> |
| <tfoot align="center" valign="middle"> |
| <tr> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| </tr> |
| </tfoot> |
| <tbody align="center" valign="middle"> |
| <tr> |
| <td axis="center" id="Table-3" abbr="maiden2" align="center" bgcolor="#FF0000" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-2" valign="middle" width="175">EMP0001</td> |
| <td headers="header-2">Margaret Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| <td>Female</td> |
| <td>1230 North Ave. Dallas, Texas 98551</td> |
| </tr> |
| <tr> |
| <td>EMP0002</td> |
| <td>Martha Raynolds</td> |
| <td>Secretary</td> |
| <td>35,000</td> |
| <td>Female</td> |
| <td>1900 Dallas Road Dallas, Texas 98554</td> |
| </tr> |
| </tbody> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablesection.html |
|---|
| 0,0 → 1,62 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - TABLESECTION</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <TABLE ALIGN="center" SUMMARY="Table 1"> |
| <TBODY> |
| <TR> |
| <TH>Id</TH> |
| <TH>Name</TH> |
| <TH>Position</TH> |
| <TH>Salary</TH> |
| </TR> |
| </TBODY> |
| </TABLE> |
| <TABLE ID="table-1" ALIGN="center" BORDER="4" BGCOLOR="#ff0000" FRAME="border" CELLPADDING="2" CELLSPACING="2" SUMMARY="HTML Control Table" RULES="all" WIDTH="680"> |
| <CAPTION ALIGN="top">Table Caption</CAPTION> |
| <THEAD ALIGN="center" VALIGN="middle" CHAR="*" CHAROFF="1"> |
| <TR ALIGN="center" BGCOLOR="#00FFFF" VALIGN="middle" CHAR="*" CHAROFF="1"> |
| <TH ID="header-1">Employee Id</TH> |
| <TH ID="header-2" ABBR="maiden" AXIS="center" ALIGN="center" BGCOLOR="#00FFFF" COLSPAN="1" HEIGHT="50" NOWRAP="nowrap" ROWSPAN="1" SCOPE="col" HEADERS="header-1" VALIGN="middle" WIDTH="100">Employee Name</TH> |
| <TH>Position</TH> |
| <TH>Salary</TH> |
| <TH>Gender</TH> |
| <TH>Address</TH> |
| </TR> |
| </THEAD> |
| <TFOOT ALIGN="center" VALIGN="middle" CHAR="+" CHAROFF="2"> |
| <TR> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| <TH>next page ...</TH> |
| </TR> |
| </TFOOT> |
| <TBODY ALIGN="center" VALIGN="middle" CHAR="$" CHAROFF="3"> |
| <TR> |
| <TD AXIS="center" ID="Table-3" ABBR="maiden2" ALIGN="center" BGCOLOR="#FF0000" COLSPAN="1" HEIGHT="50" NOWRAP="nowrap" ROWSPAN="1" SCOPE="col" HEADERS="header-2" VALIGN="middle" WIDTH="175">EMP0001</TD> |
| <TD HEADERS="header-2">Margaret Martin</TD> |
| <TD>Accountant</TD> |
| <TD>56,000</TD> |
| <TD>Female</TD> |
| <TD>1230 North Ave. Dallas, Texas 98551</TD> |
| </TR> |
| <TR> |
| <TD>EMP0002</TD> |
| <TD>Martha Raynolds</TD> |
| <TD>Secretary</TD> |
| <TD>35,000</TD> |
| <TD>Female</TD> |
| <TD>1900 Dallas Road Dallas, Texas 98554</TD> |
| </TR> |
| </TBODY> |
| </TABLE> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablesection.xhtml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLESECTION</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table align="center" summary="Table 1"> |
| <tbody> |
| <tr> |
| <th>Id</th> |
| <th>Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| </tbody> |
| </table> |
| <table id="table-1" align="center" border="4" bgcolor="#ff0000" frame="border" cellpadding="2" cellspacing="2" summary="HTML Control Table" rules="all" width="680"> |
| <caption align="top">Table Caption</caption> |
| <thead align="center" valign="middle" char="*" charoff="1"> |
| <tr align="center" bgcolor="#00FFFF" valign="middle" char="*" charoff="1"> |
| <th id="header-1">Employee Id</th> |
| <th id="header-2" abbr="maiden" axis="center" align="center" bgcolor="#00FFFF" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-1" valign="middle" width="100">Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| <th>Gender</th> |
| <th>Address</th> |
| </tr> |
| </thead> |
| <tfoot align="center" valign="middle" char="+" charoff="2"> |
| <tr> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| </tr> |
| </tfoot> |
| <tbody align="center" valign="middle" char="$" charoff="3"> |
| <tr> |
| <td axis="center" id="Table-3" abbr="maiden2" align="center" bgcolor="#FF0000" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-2" valign="middle" width="175">EMP0001</td> |
| <td headers="header-2">Margaret Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| <td>Female</td> |
| <td>1230 North Ave. Dallas, Texas 98551</td> |
| </tr> |
| <tr> |
| <td>EMP0002</td> |
| <td>Martha Raynolds</td> |
| <td>Secretary</td> |
| <td>35,000</td> |
| <td>Female</td> |
| <td>1900 Dallas Road Dallas, Texas 98554</td> |
| </tr> |
| </tbody> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/tablesection.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TABLESECTION</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <table align="center" summary="Table 1"> |
| <tbody> |
| <tr> |
| <th>Id</th> |
| <th>Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| </tr> |
| </tbody> |
| </table> |
| <table id="table-1" align="center" border="4" bgcolor="#ff0000" frame="border" cellpadding="2" cellspacing="2" summary="HTML Control Table" rules="all" width="680"> |
| <caption align="top">Table Caption</caption> |
| <thead align="center" valign="middle" char="*" charoff="1"> |
| <tr align="center" bgcolor="#00FFFF" valign="middle" char="*" charoff="1"> |
| <th id="header-1">Employee Id</th> |
| <th id="header-2" abbr="maiden" axis="center" align="center" bgcolor="#00FFFF" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-1" valign="middle" width="100">Employee Name</th> |
| <th>Position</th> |
| <th>Salary</th> |
| <th>Gender</th> |
| <th>Address</th> |
| </tr> |
| </thead> |
| <tfoot align="center" valign="middle" char="+" charoff="2"> |
| <tr> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| <th>next page ...</th> |
| </tr> |
| </tfoot> |
| <tbody align="center" valign="middle" char="$" charoff="3"> |
| <tr> |
| <td axis="center" id="Table-3" abbr="maiden2" align="center" bgcolor="#FF0000" colspan="1" height="50" nowrap="nowrap" rowspan="1" scope="col" headers="header-2" valign="middle" width="175">EMP0001</td> |
| <td headers="header-2">Margaret Martin</td> |
| <td>Accountant</td> |
| <td>56,000</td> |
| <td>Female</td> |
| <td>1230 North Ave. Dallas, Texas 98551</td> |
| </tr> |
| <tr> |
| <td>EMP0002</td> |
| <td>Martha Raynolds</td> |
| <td>Secretary</td> |
| <td>35,000</td> |
| <td>Female</td> |
| <td>1900 Dallas Road Dallas, Texas 98554</td> |
| </tr> |
| </tbody> |
| </table> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/textarea.html |
|---|
| 0,0 → 1,26 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - TEXTAREA</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form1" ACCEPT-CHARSET="US-ASCII" ACTION="./files/getData.pl" METHOD="post"> |
| <P> |
| <TEXTAREA NAME="text1" COLS="20" ROWS="7" ACCESSKEY="c" TABINDEX="5">TEXTAREA1</TEXTAREA> |
| <INPUT TYPE="submit" NAME="submit1" VALUE="Submit1"/> |
| <INPUT TYPE="reset" NAME="reset1" VALUE="Reset1"/> |
| </P> |
| </FORM> |
| <P> |
| <TEXTAREA NAME="text2" COLS="50" ROWS="2" DISABLED="disabled">TEXTAREA2</TEXTAREA> |
| <INPUT TYPE="submit" NAME="submit2" VALUE="Submit2"/> |
| <INPUT TYPE="reset" NAME="reset2" VALUE="Reset2"/> |
| <TEXTAREA NAME="text2" COLS="50" ROWS="2" READONLY="readonly">TEXTAREA3</TEXTAREA> |
| <INPUT TYPE="submit" NAME="submit2" VALUE="Submit2"/> |
| <INPUT TYPE="reset" NAME="reset3" VALUE="Reset3"/> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/textarea.xhtml |
|---|
| 0,0 → 1,27 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TEXTAREA</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <textarea name="text1" cols="20" rows="7" accesskey="c" tabindex="5">TEXTAREA1</textarea> |
| <input type="submit" name="submit1" value="Submit1"/> |
| <input type="reset" name="reset1" value="Reset1"/> |
| </p> |
| </form> |
| <p> |
| <textarea name="text2" cols="50" rows="2" disabled="disabled">TEXTAREA2</textarea> |
| <input type="submit" name="submit2" value="Submit2"/> |
| <input type="reset" name="reset2" value="Reset2"/> |
| <textarea name="text2" cols="50" rows="2" readonly="readonly">TEXTAREA3</textarea> |
| <input type="submit" name="submit3" value="Submit3"/> |
| <input type="reset" name="reset3" value="Reset3"/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/textarea.xml |
|---|
| 0,0 → 1,27 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TEXTAREA</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <textarea name="text1" cols="20" rows="7" accesskey="c" tabindex="5">TEXTAREA1</textarea> |
| <input type="submit" name="submit1" value="Submit1"/> |
| <input type="reset" name="reset1" value="Reset1"/> |
| </p> |
| </form> |
| <p> |
| <textarea name="text2" cols="50" rows="2" disabled="disabled">TEXTAREA2</textarea> |
| <input type="submit" name="submit2" value="Submit2"/> |
| <input type="reset" name="reset2" value="Reset2"/> |
| <textarea name="text2" cols="50" rows="2" readonly="readonly">TEXTAREA3</textarea> |
| <input type="submit" name="submit3" value="Submit3"/> |
| <input type="reset" name="reset3" value="Reset3"/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/title.html |
|---|
| 0,0 → 1,13 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - TITLE</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <P> |
| <BR/> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/title.xhtml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TITLE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <br/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/title.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - TITLE</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p> |
| <br/> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/ulist.html |
|---|
| 0,0 → 1,36 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - ULIST</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <OL> |
| <LI>EMP0001 |
| <UL COMPACT="compact" TYPE="disc"> |
| <LI>Margaret Martin |
| <DL> |
| <DD>Accountant</DD> |
| <DD>56,000</DD> |
| <DD>Female</DD> |
| <DD>1230 North Ave. Dallas, Texas 98551</DD> |
| </DL> |
| </LI> |
| </UL> |
| </LI> |
| <LI>EMP0002 |
| <UL> |
| <LI>Martha Raynolds |
| <DL> |
| <DD>Secretary</DD> |
| <DD>35,000</DD> |
| <DD>Female</DD> |
| <DD>1900 Dallas Road. Dallas, Texas 98554</DD> |
| </DL> |
| </LI> |
| </UL> |
| </LI> |
| </OL> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/ulist.xhtml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - ULIST</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <ol> |
| <li>EMP0001 |
| <ul compact="compact" type="disc"> |
| <li>Margaret Martin |
| <dl> |
| <dd>Accountant</dd> |
| <dd>56,000</dd> |
| <dd>Female</dd> |
| <dd>1230 North Ave. Dallas, Texas 98551</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| <li>EMP0002 |
| <ul> |
| <li>Martha Raynolds |
| <dl> |
| <dd>Secretary</dd> |
| <dd>35,000</dd> |
| <dd>Female</dd> |
| <dd>1900 Dallas Road. Dallas, Texas 98554</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| </ol> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/ulist.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - ULIST</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <ol> |
| <li>EMP0001 |
| <ul compact="compact" type="disc"> |
| <li>Margaret Martin |
| <dl> |
| <dd>Accountant</dd> |
| <dd>56,000</dd> |
| <dd>Female</dd> |
| <dd>1230 North Ave. Dallas, Texas 98551</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| <li>EMP0002 |
| <ul> |
| <li>Martha Raynolds |
| <dl> |
| <dd>Secretary</dd> |
| <dd>35,000</dd> |
| <dd>Female</dd> |
| <dd>1900 Dallas Road. Dallas, Texas 98554</dd> |
| </dl> |
| </li> |
| </ul> |
| </li> |
| </ol> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/files/w3c_main.png |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/hasFeature01.xml.kfail |
|---|
| 0,0 → 1,31 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="hasFeature01"> |
| <metadata> |
| <title>hasFeature01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| hasFeature("hTmL", null) should return true. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-5CED94D7"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <var name="state" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature obj="domImpl" var="state" feature='"hTmL"' version="version"/> |
| <assertTrue actual="state" id="hasHTMLnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/index.htm |
|---|
| 0,0 → 1,240 |
| <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> |
| <html |
| xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> |
| <head> |
| <meta http-equiv="Content-Type" content="text/html; |
| charset=us-ascii" /> |
| <title>Document Object Model (DOM) Conformance Test |
| Suites, Level 1 HTML</title> |
| <link type="text/css" rel="stylesheet" href="resources/activity-home.css" /> |
| <script type="text/javascript" |
| src="resources/toc.js"> |
| </script> |
| </head> |
| <body onload="init()"> |
| <p class="navbar" align="right"><a href="http://www.w3.org/"><img |
| align="left" src="resources/w3c_home.png" border="0" |
| alt="W3C" /></a><a href="http://www.nist.gov/"><img |
| src="resources/nist_home.gif" alt="National Institute of |
| Standards and Technology" height="45" width="231" align="left" |
| border="0" /></a><small><a href="http://www.w3.org/DOM/">About |
| DOM</a> . |
| <a href="http://www.w3.org/DOM/Activity">DOM Activity statement</a><br /> |
| <a href="http://www.w3.org/DOM/DOMTR">Technical Reports</a> . <a |
| href="http://www.w3.org/DOM/DOMTM">Technical |
| Materials</a><br /> |
| <a href="http://www.w3.org/DOM/Test/">Test Suites</a> . <a |
| href="http://www.w3.org/DOM/Test/Documents/DOMTSFAQ">Test Suites FAQ</a> . |
| <a href="http://www.w3.org/DOM/Test/MailingList">Mailing |
| Lists</a><br /> |
| Members only resource: <a href="http://www.w3.org/DOM/Group/">DOM Working |
| Group</a></small></p> |
| <h1>DOM Conformance Test Suite, Level 1 HTML</h1> |
| <div id="thisdoc"> |
| <h2>This document</h2> |
| </div> |
| <p> |
| This document describes how to run the DOM Level 1 HTML Test Suite. It also includes pointers to relevant software as well as relevant resources. |
| </p> |
| <p>The DOM TS has been developed in accordance with the <a |
| href="http://www.w3.org/DOM/DOMTS-Process">DOM Conformance Test Suites Process Document</a>. For |
| additional information and to download other DOM Test Suites, visit the <a |
| href="http://www.w3.org/DOM/Test">DOM Conformance Test Suites page</a>.</p> |
| <div id="overview"> |
| <h2>Overview</h2> |
| </div> |
| <p> |
| The DOM Conformance Test Suite consist of a series of tests that have been generated from XML test descriptions, then transformed into the two official DOM |
| bindings, Java and ECMA. In order to run the test suite, we have provided the possibility to run the |
| tests using the <a href="http://www.junit.org">JUnit</a> and <a href="http://www.jsunit.net">JsUnit</a> testing frameworks, both included in this |
| distribution. |
| </p> |
| <p>The DOM Level 1 HTML TS was released on February 13, 2002.</p> |
| <div id="latestVersion"> |
| <h2>Latest Version</h2> |
| </div> |
| <p>Download the <a |
| href="http://www.w3.org/DOM/Test/Downloads/DOMTSL1HTML">latest version</a> |
| of the DOM Level 1 HTML Test Suite.</p> |
| <div id="distribution"> |
| <h2>Distribution</h2> |
| </div> |
| <p>This distribution is organized as follows:</p> |
| <table width="100%" border="0"> |
| <tr> |
| <td width="20%">index.html</td><td>This file</td> |
| </tr> |
| <tr> |
| <td><a href="dom1-html-matrix.html">dom1-html-matrix.html</a></td> |
| <td>A cross reference of the tests to the DOM 1 HTML Recommendation, pointers to the tests and documentation.</td> |
| </tr> |
| <tr> |
| <td><a href="ecmascript/jsunit/testRunner.html">ecmascript/jsunit/testRunner.html</a></td> |
| <td>A modified <a href="http://www.jsunit.net">JSUnit</a> test runner. JSUnit is licensed under the <a href="ecmascript/jsunit/docs/gnugpl.html">GNU Public License</a></td> |
| </tr> |
| <tr> |
| <td>ecmascript/jsunit/app, ecmascript/jsunit/docs, ecmascript/jsunit/images, ecmascript/jsunit/tests</td> |
| <td>JSUnit support files</td> |
| </tr> |
| <tr> |
| <td>ecmascript/level1/html</td> |
| <td>DOM tests for use with JSUnit</td> |
| </tr> |
| <tr> |
| <td>java/dom1-html.jar</td> |
| <td>DOM tests for Java implementations, includes source code.</td> |
| </tr> |
| <tr> |
| <td>java/junit-run.jar</td> |
| <td>A test framework adapter that supports running dom1-html.jar with the JUnit 3.7 test framework.</td> |
| </tr> |
| <tr> |
| <td>java/junit.jar</td> |
| <td><a href="http://www.junit.org">JUnit 3.7</a>. JUnit 3.7 is licensed under the <a href="java/junit-license.html">IBM Public License</a>.</td> |
| </tr> |
| <tr> |
| <td>tests/*.xml</td> |
| <td>Test definitions in XML.</td> |
| </tr> |
| <tr> |
| <td><a href="tests/dom1.dtd">tests/dom1.dtd</a></td> |
| <td>Document Type Definition for DOM 1 HTML tests.</td> |
| </tr> |
| <tr> |
| <td><a href="tests/dom1.xsd">tests/dom1.xsd</a></td> |
| <td>XML Schema for DOM 1 HTML tests.</td> |
| </tr> |
| <tr> |
| <td>tests/files/</td> |
| <td>Test documents</td> |
| </tr> |
| <tr> |
| <td>doxygen/</td> |
| <td>Documentation generated by <a href="http://www.doxygen.org">doxygen</a> from the generated Java code. Useful in diagnosing test failures. |
| Click <a href="doxygen/html/hierarchy.html">here</a> for a class hierarchy.</td> |
| </tr> |
| </table> |
| <div id="runningECMA"> |
| <h2>Running the ECMAScript tests</h2> |
| </div> |
| <p>The DOM TS currently tests XML and SVG implementations of DOM Level 1 HTML. Later revisions will provide testing of HTML implementation conformance with DOM Level |
| 1.</p> |
| <p>To run the ECMAScript tests, open the <a |
| href="ecmascript/jsunit/testRunner.html">JsUnit test runner</a> in the browser |
| you want to test, press the browse button and look for the file |
| "ecmascript/level1/html/alltests.html". |
| After that, press Run to run all DOM 1 tests compatible |
| with the implementation. If you choose to run individual tests, the |
| above procedure works similarly, just browse for the test you want to |
| run in the "ecmascript/level1/html" directory.</p> |
| <p>These tests have been run with Microsoft |
| Internet Explorer 5.0 and later for Microsoft Windows and |
| Mozilla 0.9.8 and Netscape Navigator 6.2 and later for Microsoft Windows, Linux and Apple OS X. |
| Use on Apple OS X required replacing colon (:) in the test case name with slashes (/).</p> |
| <p>To test the DOM implementation of the <a href="http://www.adobe.com/svg">Adobe SVG Viewer</a>, select |
| "ecmascript/level1/html/svg-alltests.html" and press Run.</p> |
| <p>For JsUnit reference, please visit the <a href="http://www.jsunit.net">JsUnit |
| home page</a>. JsUnit will provide output with indication on how many tests that were run, how many failed and |
| how many errors were found while running. The error log points to the actual test, so identifying |
| what you need to do in your implementation is simplified.</p> |
| <div id="runningJava"> |
| <h2>Running the Java tests</h2> |
| </div> |
| <p>Running the Java tests will require placing a JAXP 1.1 compatible parser on the classpath or |
| placing a common JAXP 1.1 parser (<a href="http://xml.apache.org/crimson/index.html">Apache Xerces</a>, <a href="http://xml.apache.org/crimson/index.html">Apache Crimson</a>, <a href="http://otn.oracle.com/software/tech/xml/xdk_java/content.html">Oracle XML Developer Kit</a>, or <a href="http://www.gnu.org/software/classpathx/jaxp/">GNUJAXP</a>) in the java/ directory.</p> |
| <p>Running "java -jar dom1-html.jar" from the java/ directory will write to the console a summary of the parser under |
| test and the results of the tests run in two distinct configurations. The parser under test can |
| be selected by any mechanism supported by JAXP 1.1.</p> |
| <p>The Java tests may also be run using from JUnit TestRunner's. To run |
| all tests against the default JAXP parser in a default configuration from the JUnit text user interface, run " |
| java -classpath dom1-html.jar junit.textui.TestRunner org.w3c.domts.level1.html.TestDefaultParser". |
| The run the Swing or AWT user interfaces, replace "textui" with "swingui" or "awtui" and add "-noloading" before the |
| test case to not use JUnit's custom ClassLoader, for example, "java -classpath dom1-html.jar |
| junit.swingui.TestRunner -noloading org.w3c.domts.level1.html.TestDefaultParser"</p> |
| <p>Running "java -jar junit-run.jar" will launch the JUnit SwingUI without the custom ClassLoader.</p> |
| <p>The following TestSuite's are provided for use within JUnit TestRunner's. These provide |
| the only mechanism for testing implementations that do not support JAXP 1.1 such as Batik or |
| DOM4J.</p> |
| <table border="0" width="100%"> |
| <tr><td width="20%">org.w3c.domts.level1.html.TestBatik</td><td>Tests the <a href="http://xml.apache.org/batik">Apache Batik</a> SVG project (currently fails loading test documents).</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestCrimson</td><td>Tests the Apache Crimson Parser in the default configuration.</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestCrimsonAltConfig</td><td>Tests the Apache Crimson Parser in an alternative configuration.</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestDefaultParser</td><td>Tests the current JAXP 1.1 Parser in the default configuration.</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestDefaultParserAltConfig</td><td>Tests the current JAXP 1.1 Parser in an alternative configuration.</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestDOM4J</td><td>Tests <a href="http://www.dom4j.org">DOM4J</a>.</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestGNUJAXP</td><td>Tests the GNUJAXP Parser in the default configuration.</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestGNUJAXPAltConfig</td><td>Tests the GNUJAXP Parser in an alternative configuration.</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestOracle</td><td>Tests the Oracle XML Parser in the default configuration.</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestOracleAltConfig</td><td>Tests the Oracle XML Parser in an alternative configuration.</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestXerces</td><td>Tests the Apache Xerces Parser in the default configuration.</td></tr> |
| <tr><td>org.w3c.domts.level1.html.TestXercesAltConfig</td><td>Tests the Apache Xerces Parser in an alternative configuration.</td></tr> |
| </table> |
| <div id="feedback"> |
| <h2>Feedback</h2> |
| </div> |
| <p>We look forward to your comments. The DOM TS Group communicates primarily through the <a href="mailto:www-dom-ts@w3.org">DOM TS mailing list</a> (<a |
| href="http://lists.w3.org/Archives/Public/www-dom-ts/">archive</a>).</p> |
| <div id="copyright"> |
| <h2>Copyright</h2> |
| </div> |
| <p>Tests in this table are released under the <a |
| href="http://www.w3.org/Consortium/Legal/copyright-software-19980720.html">W3C |
| Software Copyright Notice and license</a>:<br /><a |
| href="resources/COPYRIGHT.html">Copyright</a> (c) |
| 2002 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE.<br />See W3C License <a href="http://www.w3.org/Consortium/Legal/">http://www.w3.org/Consortium/Legal/</a> for more |
| details.</p> |
| <div id="Acknowledgments"> |
| <h2>Acknowledgments</h2> |
| </div> |
| <p>The DOM TS was jointly launched by the <a href="www.w3.org">W3C</a> and <a |
| href="www.nist.org">NIST</a>. It is, however, a publically developed and open |
| framework. Reaching the point of being able to finalize and release the DOM |
| TS would not have been possible were it not for the contribution from several |
| people in the developer community, especially <a |
| href="mailto:Curt.Arnold@hyprotech.com">Curt Arnold</a> and <a |
| href="mailto:fdrake@acm.org">Fred Drake</a>.</p> |
| <hr /> |
| <address> |
| <small><a href="mailto:mary.brady@nist.gov">Mary Brady</a>, <a |
| href="http://www.nist.gov">NIST</a> representative<br /> |
| <a href="mailto:dimitris@ontologicon.com">Dimitris Dimitriadis</a>, DOM TS |
| Representative for the <a href="Group/">W3C DOM Working Group</a> <br /> |
| <a href="/People/LeHegaret/">Philippe Le Hégaret</a>, DOM |
| Activity Lead<br /> |
| </small> |
| </address> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/metadata.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE metadata SYSTEM "dom1.dtd"> |
| <metadata xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1"> |
| </metadata> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object01.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object01"> |
| <metadata> |
| <title>object01</title> |
| <creator>Netscape</creator> |
| <description> |
| Returns the FORM element containing this control. Returns null if this control is not within the context of a form. |
| The value of attribute form of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-46094773"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vform" type="HTMLFormElement" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <form interface="HTMLObjectElement" obj="testNode" var="vform"/> |
| <assertNull actual="vform" id="formLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object02.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object02"> |
| <metadata> |
| <title>object02</title> |
| <creator>Netscape</creator> |
| <description> |
| Aligns this object (vertically or horizontally) with respect to its surrounding text. |
| The value of attribute align of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-16962097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLObjectElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"middle"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object03.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object03"> |
| <metadata> |
| <title>object03</title> |
| <creator>Netscape</creator> |
| <description> |
| Space-separated list of archives |
| The value of attribute archive of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-47783837"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="varchive" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <archive interface="HTMLObjectElement" obj="testNode" var="varchive"/> |
| <assertEquals actual="varchive" expected='""' id="archiveLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object04.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object04"> |
| <metadata> |
| <title>object04</title> |
| <creator>Netscape</creator> |
| <description> |
| Width of border around the object. |
| The value of attribute border of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-82818419"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vborder" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <border interface="HTMLObjectElement" obj="testNode" var="vborder"/> |
| <assertEquals actual="vborder" expected='"0"' id="borderLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object05.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object05"> |
| <metadata> |
| <title>object05</title> |
| <creator>Netscape</creator> |
| <description> |
| Base URI for classid, data, and archive attributes. |
| The value of attribute codebase of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-25709136"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcodebase" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <codeBase interface="HTMLObjectElement" obj="testNode" var="vcodebase"/> |
| <assertEquals actual="vcodebase" expected='"http://xw2k.sdct.itl.nist.gov/brady/dom/"' id="codebaseLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object06.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object06"> |
| <metadata> |
| <title>object06</title> |
| <creator>Netscape</creator> |
| <description> |
| A URI specifying the location of the object's data. |
| The value of attribute data of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-81766986"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vdata" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <data interface="HTMLObjectElement" obj="testNode" var="vdata"/> |
| <assertEquals actual="vdata" expected='"./pix/logo.gif"' id="dataLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object07.xml.kfail |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object07"> |
| <metadata> |
| <title>object07</title> |
| <creator>Netscape</creator> |
| <description> |
| The value of attribute height of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88925838"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheight" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <height interface="HTMLObjectElement" obj="testNode" var="vheight"/> |
| <assertEquals actual="vheight" expected='"60"' id="heightLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object08.xml.kfail |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object08"> |
| <metadata> |
| <title>object08</title> |
| <creator>Netscape</creator> |
| <description> |
| Horizontal space to the left and right of this image, applet, or object. |
| The value of attribute hspace of the object element is read and checked against the expected value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-17085376"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhspace" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <hspace interface="HTMLObjectElement" obj="testNode" var="vhspace"/> |
| <assertEquals actual="vhspace" expected='"0"' id="hspaceLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object09.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object09"> |
| <metadata> |
| <title>object09</title> |
| <creator>Netscape</creator> |
| <description> |
| Message to render while loading the object. |
| The value of attribute standby of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-25039673"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vstandby" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <standby interface="HTMLObjectElement" obj="testNode" var="vstandby"/> |
| <assertEquals actual="vstandby" expected='"Loading Image ..."' id="standbyLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object10.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object10"> |
| <metadata> |
| <title>object10</title> |
| <creator>Netscape</creator> |
| <description> |
| Index that represents the element's position in the tabbing order. |
| The value of attribute tabIndex of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-27083787"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtabindex" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <tabIndex interface="HTMLObjectElement" obj="testNode" var="vtabindex"/> |
| <assertEquals actual="vtabindex" expected="0" id="tabIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object11.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object11"> |
| <metadata> |
| <title>object11</title> |
| <creator>Netscape</creator> |
| <description> |
| Content type for data downloaded via data attribute. |
| The value of attribute type of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-91665621"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vtype" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <type interface="HTMLObjectElement" obj="testNode" var="vtype"/> |
| <assertEquals actual="vtype" expected='"image/gif"' id="typeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object12.xml.kfail |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object12"> |
| <metadata> |
| <title>object12</title> |
| <creator>Netscape</creator> |
| <description> |
| The value of attribute usemap of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-6649772"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vusemap" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <useMap interface="HTMLObjectElement" obj="testNode" var="vusemap"/> |
| <assertEquals actual="vusemap" expected='"#DivLogo-map"' id="useMapLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object13.xml.kfail |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object13"> |
| <metadata> |
| <title>object13</title> |
| <creator>Netscape</creator> |
| <description> |
| Vertical space above and below this image, applet, or object. |
| The value of attribute vspace of the object element is read and checked against the expected value. |
| This test is incompatible with L2 HTML implementations due to a change in the type of the attribute. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-8682483"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=504"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvspace" type="DOMString" /> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasHTML2" type="boolean"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <hasFeature var="hasHTML2" obj="domImpl" feature='"HTML"' version='"2.0"'/> |
| <if><isFalse value="hasHTML2"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vspace interface="HTMLObjectElement" obj="testNode" var="vvspace"/> |
| <assertEquals actual="vvspace" expected='"0"' id="vspaceLink" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object14.xml.kfail |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object14"> |
| <metadata> |
| <title>object14</title> |
| <creator>Netscape</creator> |
| <description> |
| The value of attribute width of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-38538620"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLObjectElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"550"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/object15.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="object15"> |
| <metadata> |
| <title>object15</title> |
| <creator>Netscape</creator> |
| <description> |
| Content type for data downloaded via classid attribute. |
| The value of attribute codetype of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-19945008"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcodetype" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <codeType interface="HTMLObjectElement" obj="testNode" var="vcodetype"/> |
| <assertEquals actual="vcodetype" expected='"image/gif"' id="codeTypeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table01.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table01"> |
| <metadata> |
| <title>table01</title> |
| <creator>Netscape</creator> |
| <description> |
| Returns the table's CAPTION, or void if none exists. |
| The value of attribute caption of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-14594520"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcaption" type="Node"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table1" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <caption interface="HTMLTableElement" obj="testNode" var="vcaption"/> |
| <assertNull actual="vcaption" id="captionLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table02.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table02"> |
| <metadata> |
| <title>table02</title> |
| <creator>Netscape</creator> |
| <description> |
| Caption alignment with respect to the table. |
| The value of attribute align of the tablecaption element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-14594520"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcaption" type="HTMLTableCaptionElement" /> |
| <var name="valign" type="DOMString"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <caption interface="HTMLTableElement" obj="testNode" var="vcaption"/> |
| <align interface="HTMLTableCaptionElement" obj="vcaption" var="valign"/> |
| <assertEquals actual="valign" expected='"top"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table03.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table03"> |
| <metadata> |
| <title>table03</title> |
| <creator>Netscape</creator> |
| <description> |
| Alignment character for cells in a column. |
| The value of attribute ch of the tablesection element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-9530944"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <ch interface="HTMLTableSectionElement" obj="vsection" var="vch"/> |
| <assertEquals actual="vch" expected='"*"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table04.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table04"> |
| <metadata> |
| <title>table04</title> |
| <creator>Netscape</creator> |
| <description> |
| Horizontal alignment of data in cells. |
| The value of attribute align of the tablesection element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-9530944"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <align interface="HTMLTableSectionElement" obj="vsection" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table06.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table06"> |
| <metadata> |
| <title>table06</title> |
| <creator>Netscape</creator> |
| <description> |
| Vertical alignment of data in cells. |
| The value of attribute valign of the tablesection element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64197097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="vvAlign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <vAlign interface="HTMLTableSectionElement" obj="vsection" var="vvAlign"/> |
| <assertEquals actual="vvAlign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table07.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table07"> |
| <metadata> |
| <title>table07</title> |
| <creator>Netscape</creator> |
| <description> |
| The collection of rows in this table section. |
| The value of attribute rows of the tablesection element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64197097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="vcollection" type="HTMLCollection" /> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <rows interface="HTMLTableSectionElement" obj="vsection" var="vcollection"/> |
| <length interface="HTMLCollection" obj="vcollection" var="vrows" /> |
| <assertEquals actual="vrows" expected="1" id="vrowsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table08.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table08"> |
| <metadata> |
| <title>table08</title> |
| <creator>Netscape</creator> |
| <description> |
| Horizontal alignment of data in cells. |
| The value of attribute align of the tablesection element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64197097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <align interface="HTMLTableSectionElement" obj="vsection" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table09.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table09"> |
| <metadata> |
| <title>table09</title> |
| <creator>Netscape</creator> |
| <description> |
| Vertical alignment of data in cells. |
| The value of attribute valign of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-9530944"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <vAlign interface="HTMLTableSectionElement" obj="vsection" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table10.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table10"> |
| <metadata> |
| <title>table10</title> |
| <creator>Netscape</creator> |
| <description> |
| Alignment character for cells in a column. |
| The value of attribute ch of the tablesection element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64197097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <ch interface="HTMLTableSectionElement" obj="vsection" var="vch"/> |
| <assertEquals actual="vch" expected='"+"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table12.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table12"> |
| <metadata> |
| <title>table12</title> |
| <creator>Netscape</creator> |
| <description> |
| Offset of alignment character. |
| The value of attribute choff of the tablesection element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64197097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="vchoff" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <chOff interface="HTMLTableSectionElement" obj="vsection" var="vchoff"/> |
| <assertEquals actual="vchoff" expected='"1"' id="choffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table15.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table15"> |
| <metadata> |
| <title>table15</title> |
| <creator>Netscape</creator> |
| <description> |
| The collection of rows in this table section. |
| The value of attribute rows of the tablesection element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64197097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="vcollection" type="HTMLCollection" /> |
| <var name="vrows" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tHead interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <rows interface="HTMLTableSectionElement" obj="vsection" var="vcollection"/> |
| <length interface="HTMLCollection" obj="vcollection" var="vrows" /> |
| <assertEquals actual="vrows" expected="1" id="vrowsLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table17.xml.kfail |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table17"> |
| <metadata> |
| <title>table17</title> |
| <creator>Netscape</creator> |
| <description> |
| Offset of alignment character. |
| The value of attribute chOff of the tablesection element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64197097"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsection" type="HTMLTableSectionElement" /> |
| <var name="vchoff" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablesection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tFoot interface="HTMLTableElement" obj="testNode" var="vsection"/> |
| <chOff interface="HTMLTableSectionElement" obj="vsection" var="vchoff"/> |
| <assertEquals actual="vchoff" expected='"2"' id="choffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table18.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table18"> |
| <metadata> |
| <title>table18</title> |
| <creator>Netscape</creator> |
| <description> |
| The index of this cell in the row. |
| The value of attribute cellIndex of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-80748363"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcindex" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <cellIndex interface="HTMLTableCellElement" obj="testNode" var="vcindex"/> |
| <assertEquals actual="vcindex" expected="1" id="cellIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table19.xml.kfail |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table19"> |
| <metadata> |
| <title>table19</title> |
| <creator>Netscape</creator> |
| <description> |
| Abbreviation for header cells. |
| The index of this cell in the row. |
| The value of attribute abbr of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-74444037"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vabbr" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <abbr interface="HTMLTableCellElement" obj="testNode" var="vabbr"/> |
| <assertEquals actual="vabbr" expected='"hd2"' id="abbrLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table20.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table20"> |
| <metadata> |
| <title>table20</title> |
| <creator>Netscape</creator> |
| <description> |
| Names group of related headers. |
| The value of attribute axis of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-76554418"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vaxis" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <axis interface="HTMLTableCellElement" obj="testNode" var="vaxis"/> |
| <assertEquals actual="vaxis" expected='"center"' id="axisLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table21.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table21"> |
| <metadata> |
| <title>table21</title> |
| <creator>Netscape</creator> |
| <description> |
| Horizontal alignment of data in cell. |
| The value of attribute align of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-98433879"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <align interface="HTMLTableCellElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table22.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table22"> |
| <metadata> |
| <title>table22</title> |
| <creator>Netscape</creator> |
| <description> |
| Cell background color. |
| The value of attribute bgColor of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-88135431"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vbgcolor" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <bgColor interface="HTMLTableCellElement" obj="testNode" var="vbgcolor"/> |
| <assertEquals actual="vbgcolor" expected='"#FF0000"' id="bgcolorLink" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table23.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table23"> |
| <metadata> |
| <title>table23</title> |
| <creator>Netscape</creator> |
| <description> |
| Alignment character for cells in a column. |
| The value of attribute char of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-30914780"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <ch interface="HTMLTableCellElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='":"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table24.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table24"> |
| <metadata> |
| <title>table24</title> |
| <creator>Netscape</creator> |
| <description> |
| offset of alignment character. |
| The value of attribute chOff of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-20144310"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vchoff" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <chOff interface="HTMLTableCellElement" obj="testNode" var="vchoff"/> |
| <assertEquals actual="vchoff" expected='"1"' id="chOffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table25.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table25"> |
| <metadata> |
| <title>table25</title> |
| <creator>Netscape</creator> |
| <description> |
| Number of columns spanned by cell. |
| The value of attribute colspan of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-84645244"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcolspan" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <colSpan interface="HTMLTableCellElement" obj="testNode" var="vcolspan"/> |
| <assertEquals actual="vcolspan" expected="1" id="colSpanLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table26.xml.kfail |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table26"> |
| <metadata> |
| <title>table26</title> |
| <creator>Netscape</creator> |
| <description> |
| The value of attribute height of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83679212"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheight" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <height interface="HTMLTableCellElement" obj="testNode" var="vheight"/> |
| <assertEquals actual="vheight" expected='"50"' id="heightLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table27.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table27"> |
| <metadata> |
| <title>table27</title> |
| <creator>Netscape</creator> |
| <description> |
| Suppress word wrapping. |
| The value of attribute nowrap of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-62922045"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vnowrap" type="boolean" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <noWrap interface="HTMLTableCellElement" obj="testNode" var="vnowrap"/> |
| <assertTrue actual="vnowrap" id="nowrapLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table28.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table28"> |
| <metadata> |
| <title>table28</title> |
| <creator>Netscape</creator> |
| <description> |
| Number of rows spanned by cell. |
| The value of attribute rowspan of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-48237625"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrowspan" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rowSpan interface="HTMLTableCellElement" obj="testNode" var="vrowspan"/> |
| <assertEquals actual="vrowspan" expected="1" id="rowSpanLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table29.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table29"> |
| <metadata> |
| <title>table29</title> |
| <creator>Netscape</creator> |
| <description> |
| Scope covered by header cells. |
| The value of attribute scope of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-36139952"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vscope" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <scope interface="HTMLTableCellElement" obj="testNode" var="vscope"/> |
| <assertEquals actual="vscope" expected='"col"' id="scopeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table30.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table30"> |
| <metadata> |
| <title>table30</title> |
| <creator>Netscape</creator> |
| <description> |
| List of id attribute values for header cells. |
| The value of attribute headers of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-89104817"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheaders" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <headers interface="HTMLTableCellElement" obj="testNode" var="vheaders"/> |
| <assertEquals actual="vheaders" expected='"header-3"' id="headersLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table31.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table31"> |
| <metadata> |
| <title>table31</title> |
| <creator>Netscape</creator> |
| <description> |
| Vertical alignment of data in cell. |
| The value of attribute valign of the tablecell element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-58284221"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <vAlign interface="HTMLTableCellElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table32.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table32"> |
| <metadata> |
| <title>table32</title> |
| <creator>Netscape</creator> |
| <description> |
| cell width. |
| The value of attribute width of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-27480795"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecell" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"td"'/> |
| <assertSize collection="nodeList" size="4" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <width interface="HTMLTableCellElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"175"' id="vwidthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table33.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table33"> |
| <metadata> |
| <title>table33</title> |
| <creator>Netscape</creator> |
| <description> |
| Specifies the table's position with respect to the rest of the document. |
| The value of attribute align of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-23180977"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <align interface="HTMLTableElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table34.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table34"> |
| <metadata> |
| <title>table34</title> |
| <creator>Netscape</creator> |
| <description> |
| The width of the border around the table. |
| The value of attribute border of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-50969400"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vborder" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <border interface="HTMLTableElement" obj="testNode" var="vborder"/> |
| <assertEquals actual="vborder" expected='"4"' id="borderLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table35.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table35"> |
| <metadata> |
| <title>table35</title> |
| <creator>Netscape</creator> |
| <description> |
| Cell background color. |
| The value of attribute bgcolor of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83532985"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vbgcolor" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <bgColor interface="HTMLTableElement" obj="testNode" var="vbgcolor"/> |
| <assertEquals actual="vbgcolor" expected='"#ff0000"' id="bgcolorLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table36.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table36"> |
| <metadata> |
| <title>table36</title> |
| <creator>Netscape</creator> |
| <description> |
| Specifies which external table borders to render. |
| The value of attribute frame of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-64808476"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vframe" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <frame interface="HTMLTableElement" obj="testNode" var="vframe"/> |
| <assertEquals actual="vframe" expected='"border"' id="frameLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table37.xml.kfail |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table37"> |
| <metadata> |
| <title>table37</title> |
| <creator>Netscape</creator> |
| <description> |
| Specifies the horizontal and vertical space between cell content and cell borders. The value of attribute cellpadding of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-59162158"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcellpadding" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <cellPadding interface="HTMLTableElement" obj="testNode" var="vcellpadding"/> |
| <assertEquals actual="vcellpadding" expected='"2"' id="cellpaddingLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table38.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table38"> |
| <metadata> |
| <title>table38</title> |
| <creator>Netscape</creator> |
| <description> |
| Specifies the horizontal and vertical separation between cells. |
| The value of attribute cellspacing of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-68907883"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vcellspacing" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <cellSpacing interface="HTMLTableElement" obj="testNode" var="vcellspacing"/> |
| <assertEquals actual="vcellspacing" expected='"2"' id="cellspacingLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table39.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table39"> |
| <metadata> |
| <title>table39</title> |
| <creator>Netscape</creator> |
| <description> |
| Supplementary description about the purpose or structure of a table. |
| The value of attribute summary of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-44998528"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsummary" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <summary interface="HTMLTableElement" obj="testNode" var="vsummary"/> |
| <assertEquals actual="vsummary" expected='"HTML Control Table"' id="summaryLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table40.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table40"> |
| <metadata> |
| <title>table40</title> |
| <creator>Netscape</creator> |
| <description> |
| Specifies which internal table borders to render. |
| The value of attribute rules of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-26347553"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrules" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rules interface="HTMLTableElement" obj="testNode" var="vrules"/> |
| <assertEquals actual="vrules" expected='"all"' id="rulesLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table41.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table41"> |
| <metadata> |
| <title>table41</title> |
| <creator>Netscape</creator> |
| <description> |
| Specifies the desired table width. |
| The value of attribute width of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-77447361"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <width interface="HTMLTableElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"680"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table42.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table42"> |
| <metadata> |
| <title>table42</title> |
| <creator>Netscape</creator> |
| <description> |
| Horizontal alignment of data within cells of this row. |
| The value of attribute align of the tablerow element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-74098257"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="8" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <align interface="HTMLTableRowElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table43.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table43"> |
| <metadata> |
| <title>table43</title> |
| <creator>Netscape</creator> |
| <description> |
| Background color for rows. |
| The value of attribute bgcolor of the tablerow element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-18161327"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vbgcolor" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="8" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <bgColor interface="HTMLTableRowElement" obj="testNode" var="vbgcolor"/> |
| <assertEquals actual="vbgcolor" expected='"#00FFFF"' id="bgcolorLink" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table44.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table44"> |
| <metadata> |
| <title>table44</title> |
| <creator>Netscape</creator> |
| <description> |
| Vertical alignment of data within cells of this row. |
| The value of attribute valign of the tablerow element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-90000058"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="table" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="8" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <vAlign interface="HTMLTableRowElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="valignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table45.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table45"> |
| <metadata> |
| <title>table45</title> |
| <creator>Netscape</creator> |
| <description> |
| Alignment character for cells in a column. |
| The value of attribute ch of the tablerow element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-16230502"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <ch interface="HTMLTableRowElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='"*"' id="vchLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table46.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table46"> |
| <metadata> |
| <title>table46</title> |
| <creator>Netscape</creator> |
| <description> |
| Offset of alignment character. |
| The value of attribute choff of the tablerow element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-68207461"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vchoff" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <chOff interface="HTMLTableRowElement" obj="testNode" var="vchoff"/> |
| <assertEquals actual="vchoff" expected='"1"' id="choffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table47.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table47"> |
| <metadata> |
| <title>table47</title> |
| <creator>Netscape</creator> |
| <description> |
| The index of this row, relative to the entire table. |
| The value of attribute rowIndex of the table element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-67347567"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vrindex" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablerow" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="4"/> |
| <rowIndex interface="HTMLTableRowElement" obj="testNode" var="vrindex"/> |
| <assertEquals actual="vrindex" expected="2" id="rowIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table48.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table48"> |
| <metadata> |
| <title>HTMLTableColElement align</title> |
| <creator>Netscape</creator> |
| <description> |
| Horizontal alignment of cell data in column. |
| The value of attribute align of the tablecol element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-74098257"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="valign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <align interface="HTMLTableColElement" obj="testNode" var="valign"/> |
| <assertEquals actual="valign" expected='"center"' id="alignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table49.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table49"> |
| <metadata> |
| <title>table49</title> |
| <creator>Netscape</creator> |
| <description> |
| Alignment character for cells in a column. |
| The value of attribute ch of the tablecol element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-16230502"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vch" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <ch interface="HTMLTableColElement" obj="testNode" var="vch"/> |
| <assertEquals actual="vch" expected='"*"' id="chLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table50.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table50"> |
| <metadata> |
| <title>table50</title> |
| <creator>Netscape</creator> |
| <description> |
| Offset of alignment character. |
| The value of attribute choff of the tablecol element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-68207461"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vchoff" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <chOff interface="HTMLTableColElement" obj="testNode" var="vchoff"/> |
| <assertEquals actual="vchoff" expected='"20"' id="chOffLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table51.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table51"> |
| <metadata> |
| <title>table51</title> |
| <creator>Netscape</creator> |
| <description> |
| Indicates the number of columns in a group or affected by a grouping. |
| The value of attribute span of the tablecol element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-96511335"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vspan" type="int"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <span interface="HTMLTableColElement" obj="testNode" var="vspan"/> |
| <assertEquals actual="vspan" expected="1" id="spanLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table52.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table52"> |
| <metadata> |
| <title>table52</title> |
| <creator>Netscape</creator> |
| <description> |
| Vertical alignment of cell data in column. |
| The value of attribute valign of the tablecol element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-83291710"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvalign" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vAlign interface="HTMLTableColElement" obj="testNode" var="vvalign"/> |
| <assertEquals actual="vvalign" expected='"middle"' id="vAlignLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level1/html/table53.xml.kfail |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom1.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1" name="table53"> |
| <metadata> |
| <title>table53</title> |
| <creator>Netscape</creator> |
| <description> |
| Default column width. |
| The value of attribute width of the tablecol element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-25196799"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="DOMString" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="tablecol" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"col"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLTableColElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected='"20"' id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/CVS/Entries |
|---|
| 0,0 → 1,3 |
| D/core//// |
| D/events//// |
| D/html//// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level2 |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/CVS/Template |
|---|
| --- test/testcases/tests/level2/core/.cvsignore (nonexistent) |
| +++ test/testcases/tests/level2/core/.cvsignore (revision 4364) |
| @@ -0,0 +1,2 @@ |
| +dom2.dtd |
| +dom2.xsd |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/CVS/Entries |
|---|
| 0,0 → 1,287 |
| D/files//// |
| /.cvsignore/1.2/Fri Apr 3 02:47:56 2009// |
| /alltests.xml/1.13/Fri Apr 3 02:47:56 2009// |
| /attrgetownerelement01.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /attrgetownerelement02.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /attrgetownerelement03.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /attrgetownerelement04.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /attrgetownerelement05.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createAttributeNS01.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createAttributeNS02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createAttributeNS03.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /createAttributeNS04.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createAttributeNS05.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createAttributeNS06.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /createDocument01.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createDocument02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createDocument03.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createDocument04.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createDocument05.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createDocument06.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createDocument07.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createDocument08.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /createDocumentType01.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createDocumentType02.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /createDocumentType03.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createDocumentType04.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /createElementNS01.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createElementNS02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createElementNS03.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /createElementNS04.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createElementNS05.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /createElementNS06.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /documentcreateattributeNS01.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /documentcreateattributeNS02.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /documentcreateattributeNS03.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /documentcreateattributeNS04.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /documentcreateattributeNS05.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /documentcreateattributeNS06.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /documentcreateattributeNS07.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /documentcreateelementNS01.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /documentcreateelementNS02.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /documentcreateelementNS05.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /documentcreateelementNS06.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /documentgetelementbyid01.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /documentgetelementsbytagnameNS01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentgetelementsbytagnameNS02.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentgetelementsbytagnameNS03.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /documentgetelementsbytagnameNS04.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentgetelementsbytagnameNS05.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /documentimportnode01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /documentimportnode03.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /documentimportnode04.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /documentimportnode05.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode06.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode07.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode08.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /documentimportnode09.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode10.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode11.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode12.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode13.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode14.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /documentimportnode15.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode17.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode18.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /documentimportnode19.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /documentimportnode20.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode21.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documentimportnode22.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /documenttypeinternalSubset01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documenttypepublicid01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /documenttypesystemid01.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /domimplementationcreatedocument03.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /domimplementationcreatedocument04.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /domimplementationcreatedocument05.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /domimplementationcreatedocument07.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /domimplementationcreatedocumenttype01.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /domimplementationcreatedocumenttype02.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /domimplementationcreatedocumenttype04.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /domimplementationfeaturecore.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /domimplementationfeaturexmlversion2.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /domimplementationhasfeature01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /domimplementationhasfeature02.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementgetattributenodens01.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /elementgetattributenodens02.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /elementgetattributenodens03.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /elementgetattributens02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /elementgetelementsbytagnamens02.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /elementgetelementsbytagnamens04.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementgetelementsbytagnamens05.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /elementhasattribute01.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /elementhasattribute02.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementhasattribute03.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementhasattribute04.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /elementhasattributens01.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /elementhasattributens02.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementhasattributens03.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /elementremoveattributens01.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /elementsetattributenodens01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementsetattributenodens02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /elementsetattributenodens03.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /elementsetattributenodens04.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementsetattributenodens05.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /elementsetattributenodens06.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementsetattributens01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementsetattributens02.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementsetattributens03.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /elementsetattributens04.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementsetattributens05.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /elementsetattributens08.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /elementsetattributensurinull.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /getAttributeNS01.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /getAttributeNS02.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /getAttributeNS03.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /getAttributeNS04.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /getAttributeNS05.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /getAttributeNodeNS01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /getAttributeNodeNS02.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /getElementById01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /getElementById02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS02.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS03.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS04.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS05.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS06.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS07.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS08.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS09.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS10.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS11.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS12.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS13.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /getElementsByTagNameNS14.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /getNamedItemNS01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /getNamedItemNS02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /getNamedItemNS03.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /getNamedItemNS04.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /hasAttribute01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /hasAttribute02.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /hasAttribute03.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /hasAttribute04.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /hasAttributeNS01.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /hasAttributeNS02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /hasAttributeNS03.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /hasAttributeNS04.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /hasAttributeNS05.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /hasAttributes01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /hasAttributes02.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /hc_entitiesremovenameditemns1.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /hc_entitiessetnameditemns1.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /hc_namednodemapinvalidtype1.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /hc_nodedocumentfragmentnormalize1.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /hc_nodedocumentfragmentnormalize2.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /hc_notationsremovenameditemns1.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /hc_notationssetnameditemns1.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /importNode01.xml/1.8/Fri Apr 3 02:47:56 2009// |
| /importNode02.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /importNode03.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /importNode04.xml/1.8/Fri Apr 3 02:47:56 2009// |
| /importNode05.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /importNode06.xml/1.8/Fri Apr 3 02:47:56 2009// |
| /importNode07.xml/1.10/Fri Apr 3 02:47:56 2009// |
| /importNode08.xml/1.8/Fri Apr 3 02:47:56 2009// |
| /importNode09.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /importNode10.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /importNode11.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /importNode12.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /importNode13.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /importNode14.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /importNode15.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /importNode16.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /importNode17.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /internalSubset01.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /isSupported01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /isSupported02.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /isSupported04.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /isSupported05.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /isSupported06.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /isSupported07.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /isSupported09.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /isSupported10.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /isSupported11.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /isSupported12.xml/1.9/Fri Apr 3 02:47:56 2009// |
| /isSupported13.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /isSupported14.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /localName01.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /localName02.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /localName03.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /localName04.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /metadata.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapgetnameditemns01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /namednodemapgetnameditemns02.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /namednodemapgetnameditemns03.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /namednodemapgetnameditemns04.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapgetnameditemns05.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapgetnameditemns06.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapremovenameditemns01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapremovenameditemns02.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /namednodemapremovenameditemns03.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapremovenameditemns04.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapremovenameditemns05.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /namednodemapremovenameditemns06.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /namednodemapremovenameditemns07.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /namednodemapremovenameditemns08.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /namednodemapremovenameditemns09.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns02.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns03.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns04.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns05.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns06.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns07.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns08.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns09.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns10.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /namednodemapsetnameditemns11.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /namespaceURI01.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /namespaceURI02.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /namespaceURI03.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /namespaceURI04.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /nodegetlocalname03.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /nodegetnamespaceuri03.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /nodegetownerdocument01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /nodegetownerdocument02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /nodegetprefix03.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /nodehasattributes01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /nodehasattributes02.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /nodehasattributes03.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /nodehasattributes04.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /nodeissupported01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /nodeissupported02.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /nodeissupported03.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /nodeissupported04.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /nodeissupported05.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /nodenormalize01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /nodesetprefix01.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /nodesetprefix02.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /nodesetprefix03.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /nodesetprefix04.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /nodesetprefix05.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /nodesetprefix06.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /nodesetprefix07.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /nodesetprefix08.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /nodesetprefix09.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /normalize01.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /ownerDocument01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /ownerElement01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /ownerElement02.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /prefix01.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /prefix02.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /prefix03.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /prefix04.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /prefix05.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /prefix06.xml/1.8/Fri Apr 3 02:47:56 2009// |
| /prefix07.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /prefix08.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /prefix09.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /prefix10.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /prefix11.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /publicId01.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /removeAttributeNS01.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /removeAttributeNS02.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /removeNamedItemNS01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /removeNamedItemNS02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /removeNamedItemNS03.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /setAttributeNS01.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /setAttributeNS02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /setAttributeNS03.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /setAttributeNS04.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /setAttributeNS05.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /setAttributeNS06.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /setAttributeNS07.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /setAttributeNS09.xml/1.7/Fri Apr 3 02:47:56 2009// |
| /setAttributeNS10.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /setAttributeNodeNS01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /setAttributeNodeNS02.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /setAttributeNodeNS03.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /setAttributeNodeNS04.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /setAttributeNodeNS05.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /setNamedItemNS01.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /setNamedItemNS02.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /setNamedItemNS03.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /setNamedItemNS04.xml/1.8/Fri Apr 3 02:47:56 2009// |
| /setNamedItemNS05.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /systemId01.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level2/core |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/CVS/Template |
|---|
| --- test/testcases/tests/level2/core/alltests.xml.unknown (nonexistent) |
| +++ test/testcases/tests/level2/core/alltests.xml.unknown (revision 4364) |
| @@ -0,0 +1,301 @@ |
| +<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| +<!-- |
| +Copyright (c) 2001-2004 World Wide Web Consortium, |
| +(Massachusetts Institute of Technology, Institut National de |
| +Recherche en Informatique et en Automatique, Keio University). All |
| +Rights Reserved. This program is distributed under the W3C's Software |
| +Intellectual Property License. This program is distributed in the |
| +hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| +PURPOSE. |
| +See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| +--> |
| +<!DOCTYPE suite SYSTEM "dom2.dtd"> |
| +<suite xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="alltests"> |
| +<metadata> |
| +<title>DOM Level 2 Core Test Suite</title> |
| +<creator>DOM Test Suite Project</creator> |
| +</metadata> |
| + <suite.member href="attrgetownerelement01.xml"/> |
| + <suite.member href="attrgetownerelement02.xml"/> |
| + <suite.member href="attrgetownerelement03.xml"/> |
| + <suite.member href="attrgetownerelement04.xml"/> |
| + <suite.member href="attrgetownerelement05.xml"/> |
| + <suite.member href="createAttributeNS01.xml"/> |
| + <suite.member href="createAttributeNS02.xml"/> |
| + <suite.member href="createAttributeNS03.xml"/> |
| + <suite.member href="createAttributeNS04.xml"/> |
| + <suite.member href="createAttributeNS05.xml"/> |
| + <suite.member href="createAttributeNS06.xml"/> |
| + <suite.member href="createDocument01.xml"/> |
| + <suite.member href="createDocument02.xml"/> |
| + <suite.member href="createDocument03.xml"/> |
| + <suite.member href="createDocument04.xml"/> |
| + <suite.member href="createDocument05.xml"/> |
| + <suite.member href="createDocument06.xml"/> |
| + <suite.member href="createDocument07.xml"/> |
| + <suite.member href="createDocument08.xml"/> |
| + <suite.member href="createDocumentType01.xml"/> |
| + <suite.member href="createDocumentType02.xml"/> |
| + <suite.member href="createDocumentType03.xml"/> |
| + <suite.member href="createDocumentType04.xml"/> |
| + <suite.member href="createElementNS01.xml"/> |
| + <suite.member href="createElementNS02.xml"/> |
| + <suite.member href="createElementNS03.xml"/> |
| + <suite.member href="createElementNS04.xml"/> |
| + <suite.member href="createElementNS05.xml"/> |
| + <suite.member href="documentcreateattributeNS01.xml"/> |
| + <suite.member href="documentcreateattributeNS02.xml"/> |
| + <suite.member href="documentcreateattributeNS03.xml"/> |
| + <suite.member href="documentcreateattributeNS04.xml"/> |
| + <suite.member href="documentcreateattributeNS05.xml"/> |
| + <suite.member href="documentcreateattributeNS06.xml"/> |
| + <suite.member href="documentcreateattributeNS07.xml"/> |
| + <suite.member href="documentcreateelementNS01.xml"/> |
| + <suite.member href="documentcreateelementNS02.xml"/> |
| + <suite.member href="documentcreateelementNS05.xml"/> |
| + <suite.member href="documentcreateelementNS06.xml"/> |
| + <suite.member href="documentgetelementbyid01.xml"/> |
| + <suite.member href="documentgetelementsbytagnameNS01.xml"/> |
| + <suite.member href="documentgetelementsbytagnameNS02.xml"/> |
| + <suite.member href="documentgetelementsbytagnameNS03.xml"/> |
| + <suite.member href="documentgetelementsbytagnameNS04.xml"/> |
| + <suite.member href="documentgetelementsbytagnameNS05.xml"/> |
| + <suite.member href="documentimportnode01.xml"/> |
| + <suite.member href="documentimportnode02.xml"/> |
| + <suite.member href="documentimportnode03.xml"/> |
| + <suite.member href="documentimportnode04.xml"/> |
| + <suite.member href="documentimportnode05.xml"/> |
| + <suite.member href="documentimportnode06.xml"/> |
| + <suite.member href="documentimportnode07.xml"/> |
| + <suite.member href="documentimportnode08.xml"/> |
| + <suite.member href="documentimportnode09.xml"/> |
| + <suite.member href="documentimportnode10.xml"/> |
| + <suite.member href="documentimportnode11.xml"/> |
| + <suite.member href="documentimportnode12.xml"/> |
| + <suite.member href="documentimportnode13.xml"/> |
| + <suite.member href="documentimportnode14.xml"/> |
| + <suite.member href="documentimportnode15.xml"/> |
| + <suite.member href="documentimportnode17.xml"/> |
| + <suite.member href="documentimportnode18.xml"/> |
| + <suite.member href="documentimportnode19.xml"/> |
| + <suite.member href="documentimportnode20.xml"/> |
| + <suite.member href="documentimportnode21.xml"/> |
| + <suite.member href="documentimportnode22.xml"/> |
| + <suite.member href="documenttypeinternalSubset01.xml"/> |
| + <suite.member href="documenttypepublicid01.xml"/> |
| + <suite.member href="documenttypesystemid01.xml"/> |
| + <suite.member href="domimplementationcreatedocument03.xml"/> |
| + <suite.member href="domimplementationcreatedocument04.xml"/> |
| + <suite.member href="domimplementationcreatedocument05.xml"/> |
| + <suite.member href="domimplementationcreatedocument07.xml"/> |
| + <suite.member href="domimplementationcreatedocumenttype01.xml"/> |
| + <suite.member href="domimplementationcreatedocumenttype02.xml"/> |
| + <suite.member href="domimplementationcreatedocumenttype04.xml"/> |
| + <suite.member href="domimplementationfeaturecore.xml"/> |
| + <suite.member href="domimplementationfeaturexmlversion2.xml"/> |
| + <suite.member href="domimplementationhasfeature01.xml"/> |
| + <suite.member href="domimplementationhasfeature02.xml"/> |
| + <suite.member href="elementgetattributenodens01.xml"/> |
| + <suite.member href="elementgetattributenodens02.xml"/> |
| + <suite.member href="elementgetattributenodens03.xml"/> |
| + <suite.member href="elementgetattributens02.xml"/> |
| + <suite.member href="elementgetelementsbytagnamens02.xml"/> |
| + <suite.member href="elementgetelementsbytagnamens04.xml"/> |
| + <suite.member href="elementgetelementsbytagnamens05.xml"/> |
| + <suite.member href="elementhasattribute01.xml"/> |
| + <suite.member href="elementhasattribute02.xml"/> |
| + <suite.member href="elementhasattribute03.xml"/> |
| + <suite.member href="elementhasattribute04.xml"/> |
| + <suite.member href="elementhasattributens01.xml"/> |
| + <suite.member href="elementhasattributens02.xml"/> |
| + <suite.member href="elementhasattributens03.xml"/> |
| + <suite.member href="elementremoveattributens01.xml"/> |
| + <suite.member href="elementsetattributenodens01.xml"/> |
| + <suite.member href="elementsetattributenodens02.xml"/> |
| + <suite.member href="elementsetattributenodens03.xml"/> |
| + <suite.member href="elementsetattributenodens04.xml"/> |
| + <suite.member href="elementsetattributenodens05.xml"/> |
| + <suite.member href="elementsetattributenodens06.xml"/> |
| + <suite.member href="elementsetattributens01.xml"/> |
| + <suite.member href="elementsetattributens02.xml"/> |
| + <suite.member href="elementsetattributens03.xml"/> |
| + <suite.member href="elementsetattributens04.xml"/> |
| + <suite.member href="elementsetattributens05.xml"/> |
| + <suite.member href="elementsetattributens08.xml"/> |
| + <suite.member href="elementsetattributensurinull.xml"/> |
| + <suite.member href="getAttributeNS01.xml"/> |
| + <suite.member href="getAttributeNS02.xml"/> |
| + <suite.member href="getAttributeNS03.xml"/> |
| + <suite.member href="getAttributeNS04.xml"/> |
| + <suite.member href="getAttributeNS05.xml"/> |
| + <suite.member href="getAttributeNodeNS01.xml"/> |
| + <suite.member href="getAttributeNodeNS02.xml"/> |
| + <suite.member href="getElementById01.xml"/> |
| + <suite.member href="getElementById02.xml"/> |
| + <suite.member href="getElementsByTagNameNS01.xml"/> |
| + <suite.member href="getElementsByTagNameNS02.xml"/> |
| + <suite.member href="getElementsByTagNameNS03.xml"/> |
| + <suite.member href="getElementsByTagNameNS04.xml"/> |
| + <suite.member href="getElementsByTagNameNS05.xml"/> |
| + <suite.member href="getElementsByTagNameNS06.xml"/> |
| + <suite.member href="getElementsByTagNameNS07.xml"/> |
| + <suite.member href="getElementsByTagNameNS08.xml"/> |
| + <suite.member href="getElementsByTagNameNS09.xml"/> |
| + <suite.member href="getElementsByTagNameNS10.xml"/> |
| + <suite.member href="getElementsByTagNameNS11.xml"/> |
| + <suite.member href="getElementsByTagNameNS12.xml"/> |
| + <suite.member href="getElementsByTagNameNS13.xml"/> |
| + <suite.member href="getElementsByTagNameNS14.xml"/> |
| + <suite.member href="getNamedItemNS01.xml"/> |
| + <suite.member href="getNamedItemNS02.xml"/> |
| + <suite.member href="getNamedItemNS03.xml"/> |
| + <suite.member href="getNamedItemNS04.xml"/> |
| + <suite.member href="hasAttribute01.xml"/> |
| + <suite.member href="hasAttribute02.xml"/> |
| + <suite.member href="hasAttribute03.xml"/> |
| + <suite.member href="hasAttribute04.xml"/> |
| + <suite.member href="hasAttributeNS01.xml"/> |
| + <suite.member href="hasAttributeNS02.xml"/> |
| + <suite.member href="hasAttributeNS03.xml"/> |
| + <suite.member href="hasAttributeNS04.xml"/> |
| + <suite.member href="hasAttributeNS05.xml"/> |
| + <suite.member href="hasAttributes01.xml"/> |
| + <suite.member href="hasAttributes02.xml"/> |
| + <suite.member href="hc_entitiesremovenameditemns1.xml"/> |
| + <suite.member href="hc_entitiessetnameditemns1.xml"/> |
| + <suite.member href="hc_namednodemapinvalidtype1.xml"/> |
| + <suite.member href="hc_nodedocumentfragmentnormalize1.xml"/> |
| + <suite.member href="hc_nodedocumentfragmentnormalize2.xml"/> |
| + <suite.member href="hc_notationsremovenameditemns1.xml"/> |
| + <suite.member href="hc_notationssetnameditemns1.xml"/> |
| + <suite.member href="importNode01.xml"/> |
| + <suite.member href="importNode02.xml"/> |
| + <suite.member href="importNode03.xml"/> |
| + <suite.member href="importNode04.xml"/> |
| + <suite.member href="importNode05.xml"/> |
| + <suite.member href="importNode06.xml"/> |
| + <suite.member href="importNode07.xml"/> |
| + <suite.member href="importNode08.xml"/> |
| + <suite.member href="importNode09.xml"/> |
| + <suite.member href="importNode10.xml"/> |
| + <suite.member href="importNode11.xml"/> |
| + <suite.member href="importNode12.xml"/> |
| + <suite.member href="importNode13.xml"/> |
| + <suite.member href="importNode14.xml"/> |
| + <suite.member href="importNode15.xml"/> |
| + <suite.member href="importNode16.xml"/> |
| + <suite.member href="importNode17.xml"/> |
| + <suite.member href="internalSubset01.xml"/> |
| + <suite.member href="isSupported01.xml"/> |
| + <suite.member href="isSupported02.xml"/> |
| + <suite.member href="isSupported04.xml"/> |
| + <suite.member href="isSupported05.xml"/> |
| + <suite.member href="isSupported06.xml"/> |
| + <suite.member href="isSupported07.xml"/> |
| + <suite.member href="isSupported09.xml"/> |
| + <suite.member href="isSupported10.xml"/> |
| + <suite.member href="isSupported11.xml"/> |
| + <suite.member href="isSupported12.xml"/> |
| + <suite.member href="isSupported13.xml"/> |
| + <suite.member href="isSupported14.xml"/> |
| + <suite.member href="localName01.xml"/> |
| + <suite.member href="localName02.xml"/> |
| + <suite.member href="localName03.xml"/> |
| + <suite.member href="localName04.xml"/> |
| + <suite.member href="namednodemapgetnameditemns01.xml"/> |
| + <suite.member href="namednodemapgetnameditemns02.xml"/> |
| + <suite.member href="namednodemapgetnameditemns03.xml"/> |
| + <suite.member href="namednodemapgetnameditemns04.xml"/> |
| + <suite.member href="namednodemapgetnameditemns05.xml"/> |
| + <suite.member href="namednodemapgetnameditemns06.xml"/> |
| + <suite.member href="namednodemapremovenameditemns01.xml"/> |
| + <suite.member href="namednodemapremovenameditemns02.xml"/> |
| + <suite.member href="namednodemapremovenameditemns03.xml"/> |
| + <suite.member href="namednodemapremovenameditemns04.xml"/> |
| + <suite.member href="namednodemapremovenameditemns05.xml"/> |
| + <suite.member href="namednodemapremovenameditemns06.xml"/> |
| + <suite.member href="namednodemapremovenameditemns07.xml"/> |
| + <suite.member href="namednodemapremovenameditemns08.xml"/> |
| + <suite.member href="namednodemapremovenameditemns09.xml"/> |
| + <suite.member href="namednodemapsetnameditemns01.xml"/> |
| + <suite.member href="namednodemapsetnameditemns02.xml"/> |
| + <suite.member href="namednodemapsetnameditemns03.xml"/> |
| + <suite.member href="namednodemapsetnameditemns04.xml"/> |
| + <suite.member href="namednodemapsetnameditemns05.xml"/> |
| + <suite.member href="namednodemapsetnameditemns06.xml"/> |
| + <suite.member href="namednodemapsetnameditemns07.xml"/> |
| + <suite.member href="namednodemapsetnameditemns08.xml"/> |
| + <suite.member href="namednodemapsetnameditemns09.xml"/> |
| + <suite.member href="namednodemapsetnameditemns10.xml"/> |
| + <suite.member href="namednodemapsetnameditemns11.xml"/> |
| + <suite.member href="namespaceURI01.xml"/> |
| + <suite.member href="namespaceURI02.xml"/> |
| + <suite.member href="namespaceURI03.xml"/> |
| + <suite.member href="namespaceURI04.xml"/> |
| + <suite.member href="nodegetlocalname03.xml"/> |
| + <suite.member href="nodegetnamespaceuri03.xml"/> |
| + <suite.member href="nodegetownerdocument01.xml"/> |
| + <suite.member href="nodegetownerdocument02.xml"/> |
| + <suite.member href="nodegetprefix03.xml"/> |
| + <suite.member href="nodehasattributes01.xml"/> |
| + <suite.member href="nodehasattributes02.xml"/> |
| + <suite.member href="nodehasattributes03.xml"/> |
| + <suite.member href="nodehasattributes04.xml"/> |
| + <suite.member href="nodeissupported01.xml"/> |
| + <suite.member href="nodeissupported02.xml"/> |
| + <suite.member href="nodeissupported03.xml"/> |
| + <suite.member href="nodeissupported04.xml"/> |
| + <suite.member href="nodeissupported05.xml"/> |
| + <suite.member href="nodenormalize01.xml"/> |
| + <suite.member href="nodesetprefix01.xml"/> |
| + <suite.member href="nodesetprefix02.xml"/> |
| + <suite.member href="nodesetprefix03.xml"/> |
| + <suite.member href="nodesetprefix04.xml"/> |
| + <suite.member href="nodesetprefix05.xml"/> |
| + <suite.member href="nodesetprefix06.xml"/> |
| + <suite.member href="nodesetprefix07.xml"/> |
| + <suite.member href="nodesetprefix08.xml"/> |
| + <suite.member href="nodesetprefix09.xml"/> |
| + <suite.member href="normalize01.xml"/> |
| + <suite.member href="ownerDocument01.xml"/> |
| + <suite.member href="ownerElement01.xml"/> |
| + <suite.member href="ownerElement02.xml"/> |
| + <suite.member href="prefix01.xml"/> |
| + <suite.member href="prefix02.xml"/> |
| + <suite.member href="prefix03.xml"/> |
| + <suite.member href="prefix04.xml"/> |
| + <suite.member href="prefix05.xml"/> |
| + <suite.member href="prefix06.xml"/> |
| + <suite.member href="prefix07.xml"/> |
| + <suite.member href="prefix08.xml"/> |
| + <suite.member href="prefix09.xml"/> |
| + <suite.member href="prefix10.xml"/> |
| + <suite.member href="prefix11.xml"/> |
| + <suite.member href="publicId01.xml"/> |
| + <suite.member href="removeAttributeNS01.xml"/> |
| + <suite.member href="removeAttributeNS02.xml"/> |
| + <suite.member href="removeNamedItemNS01.xml"/> |
| + <suite.member href="removeNamedItemNS02.xml"/> |
| + <suite.member href="removeNamedItemNS03.xml"/> |
| + <suite.member href="setAttributeNS01.xml"/> |
| + <suite.member href="setAttributeNS02.xml"/> |
| + <suite.member href="setAttributeNS03.xml"/> |
| + <suite.member href="setAttributeNS04.xml"/> |
| + <suite.member href="setAttributeNS05.xml"/> |
| + <suite.member href="setAttributeNS06.xml"/> |
| + <suite.member href="setAttributeNS07.xml"/> |
| + <suite.member href="setAttributeNS09.xml"/> |
| + <suite.member href="setAttributeNS10.xml"/> |
| + <suite.member href="setAttributeNodeNS01.xml"/> |
| + <suite.member href="setAttributeNodeNS02.xml"/> |
| + <suite.member href="setAttributeNodeNS03.xml"/> |
| + <suite.member href="setAttributeNodeNS04.xml"/> |
| + <suite.member href="setAttributeNodeNS05.xml"/> |
| + <suite.member href="setNamedItemNS01.xml"/> |
| + <suite.member href="setNamedItemNS02.xml"/> |
| + <suite.member href="setNamedItemNS03.xml"/> |
| + <suite.member href="setNamedItemNS04.xml"/> |
| + <suite.member href="setNamedItemNS05.xml"/> |
| + <suite.member href="systemId01.xml"/> |
| +</suite> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/attrgetownerelement01.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="attrgetownerelement01"> |
| <metadata> |
| <title>attrgetownerelement01</title> |
| <creator>IBM</creator> |
| <description> |
| The "getOwnerElement()" will return the Element node this attribute is attached to or |
| null if this attribute is not in use. |
| Retreive the default attribute defaultAttr and check its owner element. Verify if the name |
| the nodeName of the returned ownerElement is emp:employee. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Attr-ownerElement"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attr" type="Attr"/> |
| <var name="element" type="Element"/> |
| <var name="ownerElement" type="Element"/> |
| <var name="ownerElementName" type="DOMString"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"http://www.nist.gov"' localName='"employee"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <getNamedItemNS var="attr" obj="attributes" namespaceURI="nullNS" localName='"defaultAttr"'/> |
| <ownerElement var="ownerElement" obj="attr"/> |
| <nodeName var="ownerElementName" obj="ownerElement"/> |
| <assertEquals actual="ownerElementName" expected='"emp:employee"' id="attrgetownerelement01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/attrgetownerelement02.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="attrgetownerelement02"> |
| <metadata> |
| <title>attrgetownerelement02</title> |
| <creator>IBM</creator> |
| <description> |
| The "getOwnerElement()" will return the Element node this attribute |
| is attached to or null if this attribute is not in use. |
| Create a new element and attribute node, attach the attribute to the element. |
| Check the value of owner element of the new attribute node |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Attr-ownerElement"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="ownerElement" type="Element"/> |
| <var name="ownerElementName" type="DOMString"/> |
| <var name="attr" type="Attr"/> |
| <var name="newAttr" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createElement var="element" obj="doc" tagName='"root"'/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/DOM/L1"' qualifiedName='"L1:att"'/> |
| <setAttributeNodeNS var="newAttr" obj="element" newAttr="attr"/> |
| <ownerElement var="ownerElement" obj="attr"/> |
| <nodeName var="ownerElementName" obj="ownerElement"/> |
| <assertEquals actual="ownerElementName" expected='"root"' id="attrgetownerelement02" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/attrgetownerelement03.xml.unknown |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="attrgetownerelement03"> |
| <metadata> |
| <title>attrgetownerelement03</title> |
| <creator>IBM</creator> |
| <description> |
| The "getOwnerElement()" will return the Element node this attribute |
| is attached to or null if this attribute is not in use. |
| Create a new attribute node for this document node. Since the newly attribute is |
| not it use its owner element should be null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Attr-ownerElement"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="ownerElement" type="Node"/> |
| <var name="attr" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/DOM"' qualifiedName='"dom:attr"'/> |
| <ownerElement var="ownerElement" obj="attr"/> |
| <assertNull actual="ownerElement" id="attrgetownerelement03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/attrgetownerelement04.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| +(Massachusetts Institute of Technology, Institut National de |
| +Recherche en Informatique et en Automatique, Keio University). All |
| +Rights Reserved. This program is distributed under the W3C's Software |
| +Intellectual Property License. This program is distributed in the |
| +hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| + |
| +See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| +--> |
| +<!DOCTYPE test SYSTEM "dom2.dtd"> |
| +<test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="attrgetownerelement04"> |
| +<metadata> |
| +<title>attrgetownerelement04</title> |
| +<creator>IBM</creator> |
| +<description> |
| + The "getOwnerElement()" will return the Element node this attribute is attached to or |
| + null if this attribute is not in use. |
| + Import an attribute node to another document. If an Attr node is imported, its |
| + ownerElement attribute should be set to null. Verify if the ownerElement has been set |
| + to null. |
| +</description> |
| +<contributor>Neil Delima</contributor> |
| +<date qualifier="created">2002-04-28</date> |
| +<subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Attr-ownerElement"/> |
| +</metadata> |
| +<implementationAttribute name="namespaceAware" value="true"/> |
| +<var name="doc" type="Document"/> |
| +<var name="docImp" type="Document"/> |
| +<var name="ownerElement" type="Node"/> |
| +<var name="element" type="Element"/> |
| +<var name="attr" type="Attr"/> |
| +<var name="addresses" type="NodeList"/> |
| +<load var="doc" href="staffNS" willBeModified="false"/> |
| +<assertNotNull actual="element" id="empAddressNotNull"/> |
| +<getAttributeNodeNS var="attr" obj="element" namespaceURI='"http://www.nist.gov"' localName='"zone"'/> |
| +<importNode var="attrImp" obj="docImp" importedNode="attr" deep="true"/> |
| +<ownerElement var="ownerElement" obj="attrImp"/> |
| +<assertNull actual="ownerElement" id="attrgetownerelement04"/> |
| +</test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/attrgetownerelement05.xml.unknown |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="attrgetownerelement05"> |
| <metadata> |
| <title>attrgetownerelement05</title> |
| <creator>IBM</creator> |
| <description> |
| The "getOwnerElement()" will return the Element node this attribute is attached to |
| or null if this attribute is not in use. |
| Retreive an element and its attributes. Then remove the element and check the name of |
| the ownerElement of attribute of the attribute "street". |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Attr-ownerElement"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Node"/> |
| <var name="ownerElement" type="Element"/> |
| <var name="parentElement" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="ownerElementName" type="DOMString"/> |
| <var name="attr" type="Attr"/> |
| <var name="removedChild" type="Node"/> |
| <var name="nodeMap" type="NamedNodeMap"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <parentNode interface="Node" var="parentElement" obj="element"/> |
| <attributes var="nodeMap" obj="element"/> |
| <removeChild var="removedChild" obj="parentElement" oldChild="element"/> |
| <getNamedItemNS var="attr" obj="nodeMap" namespaceURI="nullNS" localName='"street"'/> |
| <ownerElement var="ownerElement" obj="attr"/> |
| <nodeName var="ownerElementName" obj="ownerElement"/> |
| <assertEquals actual="ownerElementName" expected='"address"' id="attrgetownerelement05" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createAttributeNS01.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createAttributeNS01"> |
| <metadata> |
| <title>createAttributeNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "createAttributeNS(namespaceURI,qualifiedName)" method for a |
| Document should raise NAMESPACE_ERR DOMException |
| if qualifiedName is malformed. |
| Invoke method createAttributeNS(namespaceURI,qualifiedName) on |
| the XMLNS Document with namespaceURI being "http://www.ecommerce.org/", |
| qualifiedName as "prefix::local". Method should raise |
| NAMESPACE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-DocCrAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.ecommerce.org/""/> |
| <var name="malformedName" type="DOMString" value=""prefix::local""/> |
| <var name="doc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI="namespaceURI" qualifiedName="malformedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createAttributeNS02.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createAttributeNS02"> |
| <metadata> |
| <title>createAttributeNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "createAttributeNS(namespaceURI,qualifiedName)" method for a |
| Document should raise NAMESPACE_ERR DOMException |
| if qualifiedName has a prefix and namespaceURI is null. |
| Invoke method createAttributeNS(namespaceURI,qualifiedName) on this document |
| with namespaceURI being null and qualifiedName contains the prefix "person". |
| Method should raise NAMESPACE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-DocCrAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" isNull="true"/> |
| <var name="qualifiedName" type="DOMString" value=""prefix:local""/> |
| <var name="doc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createAttributeNS03.xml.unknown |
|---|
| 0,0 → 1,78 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createAttributeNS03"> |
| <metadata> |
| <title>createAttributeNS03</title> |
| <creator>NIST</creator> |
| <description> |
| The "createAttributeNS(namespaceURI,qualifiedName)" method for a |
| Document should raise INVALID_CHARACTER_ERR DOMException |
| if qualifiedName contains an illegal character. |
| Invoke method createAttributeNS(namespaceURI,qualifiedName) on this document |
| with qualifiedName containing an illegal character from illegalChars[]. |
| Method should raise INVALID_CHARACTER_ERR DOMException for all |
| characters in illegalChars[]. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-DocCrAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.wedding.com/""/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="illegalQNames" type="List"> |
| <member>"person:{"</member> |
| <member>"person:}"</member> |
| <member>"person:~"</member> |
| <member>"person:'"</member> |
| <member>"person:!"</member> |
| <member>"person:@"</member> |
| <member>"person:#"</member> |
| <member>"person:$"</member> |
| <member>"person:%"</member> |
| <member>"person:^"</member> |
| <member>"person:&"</member> |
| <member>"person:*"</member> |
| <member>"person:("</member> |
| <member>"person:)"</member> |
| <member>"person:+"</member> |
| <member>"person:="</member> |
| <member>"person:["</member> |
| <member>"person:]"</member> |
| <member>"person:\\"</member> |
| <member>"person:/"</member> |
| <member>"person:;"</member> |
| <member>"person:`"</member> |
| <member>"person:<"</member> |
| <member>"person:>"</member> |
| <member>"person:,"</member> |
| <member>"person:a "</member> |
| <member>"person:\""</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <for-each collection="illegalQNames" member="qualifiedName"> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createAttributeNS04.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createAttributeNS04"> |
| <metadata> |
| <title>createAttributeNS04</title> |
| <creator>NIST</creator> |
| <description> |
| The "createAttributeNS(namespaceURI,qualifiedName)" method for a |
| Document should raise NAMESPACE_ERR DOMException |
| if qualifiedName has the "xml" prefix and namespaceURI is different |
| from "http://www.w3.org/XML/1998/namespace". |
| Invoke method createAttributeNS(namespaceURI,qualifiedName) on this document |
| with qualifiedName being "xml:attr1 and namespaceURI equals |
| the string "http://www.w3.org/XML/1998/namespaces" (which differs from the required |
| string "http://www.w3.org/XML/1998/namespace"). |
| Method should raise NAMESPACE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-DocCrAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.w3.org/XML/1998/namespaces""/> |
| <var name="qualifiedName" type="DOMString" value=""xml:attr1""/> |
| <var name="doc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createAttributeNS05.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createAttributeNS05"> |
| <metadata> |
| <title>createAttributeNS05</title> |
| <creator>NIST</creator> |
| <description> |
| The "createAttributeNS(namespaceURI,qualifiedName)" method for a |
| Document should return a new Attr object given that all parameters are |
| valid and correctly formed. |
| Invoke method createAttributeNS(namespaceURI,qualifiedName) on this document with |
| parameters equal "http://www.ecommerce.org/" and "ecom:local" |
| respectively. Method should return a new Attr object whose name is "ecom:local". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1112119403"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.ecommerce.org/""/> |
| <var name="qualifiedName" type="DOMString" value=""econm:local""/> |
| <var name="doc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <name interface="Attr" obj="newAttr" var="attrName"/> |
| <assertEquals actual="attrName" expected="qualifiedName" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createAttributeNS06.xml.unknown |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createAttributeNS06"> |
| <metadata> |
| <title>createAttributeNS06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Document.createAttributeNS with an empty qualified name should cause an INVALID_CHARACTER_ERR. |
| </description> |
| <date qualifier="created">2004-03-09</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-DocCrAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=525"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value='"http://www.example.com/"'/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI="namespaceURI" qualifiedName='""'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocument01.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocument01"> |
| <metadata> |
| <title>createDocument01</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocument(namespaceURI,qualifiedName,doctype)" method for a |
| DOMImplementation should raise NAMESPACE_ERR DOMException |
| if parameter qualifiedName is malformed. |
| Retrieve the DOMImplementation on the XMLNS Document. |
| Invoke method createDocument(namespaceURI,qualifiedName,doctype) |
| on the retrieved DOMImplementation with namespaceURI being |
| the literal string "http://www.ecommerce.org/", qualifiedName as |
| "prefix::local", and doctype as null. Method should raise |
| NAMESPACE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('Level-2-Core-DOM-createDocument')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.ecommerce.org/""/> |
| <var name="malformedName" type="DOMString" value=""prefix::local""/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="aNewDoc" type="Document"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createDocument obj="domImpl" var="aNewDoc" namespaceURI="namespaceURI" qualifiedName="malformedName" doctype="docType"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocument02.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocument02"> |
| <metadata> |
| <title>createDocument02</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocument(namespaceURI,qualifiedName,doctype)" method for a |
| DOMImplementation should raise NAMESPACE_ERR DOMException |
| if qualifiedName has a prefix and namespaceURI is null. |
| Invoke method createDocument(namespaceURI,qualifiedName,doctype) on |
| this domimplementation with namespaceURI being null and qualifiedName |
| equals "k:local". Method should raise NAMESPACE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('Level-2-Core-DOM-createDocument')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" isNull="true"/> |
| <var name="qualifiedName" type="DOMString" value=""k:local""/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="aNewDoc" type="Document"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createDocument obj="domImpl" var="aNewDoc" namespaceURI="namespaceURI" qualifiedName="qualifiedName" doctype="docType"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocument03.xml.unknown |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocument03"> |
| <metadata> |
| <title>createDocument03</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocument(namespaceURI,qualifiedName,doctype)" method for a |
| DOMImplementation should raise WRONG_DOCUMENT_ERR DOMException |
| if parameter doctype has been used with a different document. |
| Invoke method createDocument(namespaceURI,qualifiedName,doctype) on |
| this domimplementation where doctype is the type of this document. |
| Method should raise WRONG_DOCUMENT_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('Level-2-Core-DOM-createDocument')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='WRONG_DOCUMENT_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.ecommerce.org/schema""/> |
| <var name="qualifiedName" type="DOMString" value=""namespaceURI:x""/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="aNewDoc" type="Document"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <implementation obj="doc" var="domImpl"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <createDocument obj="domImpl" var="aNewDoc" namespaceURI="namespaceURI" qualifiedName="qualifiedName" doctype="docType"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocument04.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocument04"> |
| <metadata> |
| <title>createDocument04</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocument(namespaceURI,qualifiedName,doctype)" method for a |
| DOMImplementation should raise WRONG_DOCUMENT_ERR DOMException |
| if parameter doctype was created from a different implementation. |
| Invoke method createDocument(namespaceURI,qualifiedName,doctype) on |
| a domimplementation that is different from this domimplementation. |
| Doctype is the type of this document. |
| Method should raise WRONG_DOCUMENT_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('Level-2-Core-DOM-createDocument')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='WRONG_DOCUMENT_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.ecommerce.org/schema""/> |
| <var name="qualifiedName" type="DOMString" value=""namespaceURI:x""/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="aNewDoc" type="Document"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <implementation obj="aNewDoc" var="domImpl"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <createDocument obj="domImpl" var="aNewDoc" namespaceURI="namespaceURI" qualifiedName="qualifiedName" doctype="docType"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocument05.xml.unknown |
|---|
| 0,0 → 1,82 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocument05"> |
| <metadata> |
| <title>createDocument05</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocument(namespaceURI,qualifiedName,doctype)" method for a |
| DOMImplementation should raise INVALID_CHARACTER_ERR DOMException |
| if parameter qualifiedName contains an illegal character. |
| Invoke method createDocument(namespaceURI,qualifiedName,doctype) on |
| this domimplementation with namespaceURI equals "http://www.ecommerce.org/schema", |
| doctype is null and qualifiedName contains an illegal character from |
| illegalChars[]. Method should raise INVALID_CHARACTER_ERR DOMException |
| for all characters in illegalChars[]. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.ecommerce.org/schema""/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="charact" type="DOMString"/> |
| <var name="illegalQNames" type="List"> |
| <member>"namespaceURI:{"</member> |
| <member>"namespaceURI:}"</member> |
| <member>"namespaceURI:~"</member> |
| <member>"namespaceURI:'"</member> |
| <member>"namespaceURI:!"</member> |
| <member>"namespaceURI:@"</member> |
| <member>"namespaceURI:#"</member> |
| <member>"namespaceURI:$"</member> |
| <member>"namespaceURI:%"</member> |
| <member>"namespaceURI:^"</member> |
| <member>"namespaceURI:&"</member> |
| <member>"namespaceURI:*"</member> |
| <member>"namespaceURI:("</member> |
| <member>"namespaceURI:)"</member> |
| <member>"namespaceURI:+"</member> |
| <member>"namespaceURI:="</member> |
| <member>"namespaceURI:["</member> |
| <member>"namespaceURI:]"</member> |
| <member>"namespaceURI:\\"</member> |
| <member>"namespaceURI:/"</member> |
| <member>"namespaceURI:;"</member> |
| <member>"namespaceURI:`"</member> |
| <member>"namespaceURI:<"</member> |
| <member>"namespaceURI:>"</member> |
| <member>"namespaceURI:,"</member> |
| <member>"namespaceURI:a "</member> |
| <member>"namespaceURI:\""</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <for-each collection="illegalQNames" member="qualifiedName"> |
| <implementation obj="doc" var="domImpl"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createDocument obj="domImpl" var="aNewDoc" namespaceURI="namespaceURI" qualifiedName="qualifiedName" doctype="docType"/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocument06.xml.unknown |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocument06"> |
| <metadata> |
| <title>createDocument06</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocument(namespaceURI,qualifiedName,doctype)" method for a |
| DOMImplementation should raise NAMESPACE_ERR DOMException |
| if qualifiedName has the "xml" prefix and namespaceURI different from |
| "http://www.w3.org/XML/1998/namespace" |
| Invoke method createDocument(namespaceURI,qualifiedName,doctype) on |
| this domimplementation with qualifiedName "xml:local" |
| and namespaceURI as the string |
| "http://www.ecommerce.org/schema" (which is different from the required |
| "http://www.w3.org/XML/1998/namespace"). Method should raise |
| NAMESPACE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('Level-2-Core-DOM-createDocument')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://ecommerce.org/schema""/> |
| <var name="qualifiedName" type="DOMString" value=""xml:local""/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="aNewDoc" type="Document"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createDocument obj="domImpl" var="aNewDoc" namespaceURI="namespaceURI" qualifiedName="qualifiedName" doctype="docType"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocument07.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocument07"> |
| <metadata> |
| <title>createDocument07</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocument(namespaceURI,qualifiedName,doctype)" method for a |
| DOMImplementation should return a new xml Document object of the |
| specified type with its document element given that all parameters are |
| valid and correctly formed. |
| Invoke method createDocument(namespaceURI,qualifiedName,doctype) on |
| this domimplementation. namespaceURI is "http://www.ecommerce.org/schema" |
| qualifiedName is "y:x" and doctype is null. |
| Method should return a new xml Document as specified by the listed parameters. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.ecommerce.org/schema""/> |
| <var name="qualifiedName" type="DOMString" value=""y:x""/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <createDocument obj="domImpl" var="aNewDoc" namespaceURI="namespaceURI" qualifiedName="qualifiedName" doctype="docType"/> |
| <nodeName var="nodeName" obj="aNewDoc"/> |
| <nodeValue var="nodeValue" obj="aNewDoc"/> |
| <assertEquals actual="nodeName" expected='"#document"' id="nodeName" ignoreCase="false"/> |
| <assertNull actual="nodeValue" id="nodeValue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocument08.xml.unknown |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocument08"> |
| <metadata> |
| <title>createDocument08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementation.createDocument with an empty qualified name should cause an INVALID_CHARACTER_ERR. |
| </description> |
| <date qualifier="created">2004-03-09</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=525"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value='"http://www.example.org/schema"'/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="charact" type="DOMString"/> |
| <implementation var="domImpl"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createDocument obj="domImpl" var="aNewDoc" namespaceURI="namespaceURI" qualifiedName='""' doctype="docType"/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocumentType01.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocumentType01"> |
| <metadata> |
| <title>createDocumentType01</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocumentType(qualifiedName,publicId,systemId)" method for a |
| DOMImplementation should raise NAMESPACE_ERR DOMException if |
| qualifiedName is malformed. |
| Retrieve the DOMImplementation on the XMLNS Document. |
| Invoke method createDocumentType(qualifiedName,publicId,systemId) |
| on the retrieved DOMImplementation with qualifiedName being the literal |
| string "prefix::local", publicId as "STAFF", and systemId as "staff". |
| Method should raise NAMESPACE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocType"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('Level-2-Core-DOM-createDocType')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="publicId" type="DOMString" value=""STAFF""/> |
| <var name="systemId" type="DOMString" value=""staff.xml""/> |
| <var name="malformedName" type="DOMString" value=""prefix::local""/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newType" type="DocumentType"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createDocumentType obj="domImpl" var="newType" publicId="publicId" qualifiedName="malformedName" systemId="systemId"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocumentType02.xml.unknown |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocumentType02"> |
| <metadata> |
| <title>createDocumentType02</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocumentType(qualifiedName,publicId,systemId)" method for a |
| DOMImplementation should raise INVALID_CHARACTER_ERR DOMException if |
| qualifiedName contains an illegal character. |
| Invoke method createDocumentType(qualifiedName,publicId,systemId) on |
| this domimplementation with qualifiedName containing an illegal character |
| from illegalChars[]. Method should raise INVALID_CHARACTER_ERR |
| DOMException for all characters in illegalChars[]. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocType"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('Level-2-Core-DOM-createDocType')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| </metadata> |
| <var name="publicId" type="DOMString" value=""http://www.localhost.com/""/> |
| <var name="systemId" type="DOMString" value=""myDoc.dtd""/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="illegalQNames" type="List"> |
| <member>"edi:{"</member> |
| <member>"edi:}"</member> |
| <member>"edi:~"</member> |
| <member>"edi:'"</member> |
| <member>"edi:!"</member> |
| <member>"edi:@"</member> |
| <member>"edi:#"</member> |
| <member>"edi:$"</member> |
| <member>"edi:%"</member> |
| <member>"edi:^"</member> |
| <member>"edi:&"</member> |
| <member>"edi:*"</member> |
| <member>"edi:("</member> |
| <member>"edi:)"</member> |
| <member>"edi:+"</member> |
| <member>"edi:="</member> |
| <member>"edi:["</member> |
| <member>"edi:]"</member> |
| <member>"edi:\\"</member> |
| <member>"edi:/"</member> |
| <member>"edi:;"</member> |
| <member>"edi:`"</member> |
| <member>"edi:<"</member> |
| <member>"edi:>"</member> |
| <member>"edi:,"</member> |
| <member>"edi:a "</member> |
| <member>"edi:\""</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <for-each collection="illegalQNames" member="qualifiedName"> |
| <implementation obj="doc" var="domImpl"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createDocumentType obj="domImpl" var="docType" qualifiedName="qualifiedName" publicId="publicId" systemId="systemId"/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocumentType03.xml.unknown |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocumentType03"> |
| <metadata> |
| <title>createDocumentType03</title> |
| <creator>NIST</creator> |
| <description> |
| The "createDocumentType(qualifiedName,publicId,systemId)" method for a |
| DOMImplementation should return a new DocumentType node |
| given that qualifiedName is valid and correctly formed. |
| Invoke method createDocumentType(qualifiedName,publicId,systemId) on |
| this domimplementation with qualifiedName "prefix:myDoc". |
| Method should return a new DocumentType node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocType"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://ecommerce.org/schema""/> |
| <var name="qualifiedName" type="DOMString" value=""prefix:myDoc""/> |
| <var name="publicId" type="DOMString" value=""http://www.localhost.com""/> |
| <var name="systemId" type="DOMString" value=""myDoc.dtd""/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newType" type="DocumentType" isNull="true"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <createDocumentType obj="domImpl" var="newType" qualifiedName="qualifiedName" publicId="publicId" systemId="systemId"/> |
| <nodeName var="nodeName" obj="newType"/> |
| <assertEquals actual="nodeName" expected='"prefix:myDoc"' ignoreCase="false" id="nodeName"/> |
| <nodeValue var="nodeValue" obj="newType"/> |
| <assertNull actual="nodeValue" id="nodeValue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createDocumentType04.xml.unknown |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createDocumentType04"> |
| <metadata> |
| <title>createDocumentType04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementation.createDocumentType with an empty name should cause an INVALID_CHARACTER_ERR. |
| </description> |
| <date qualifier="created">2004-03-09</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocType"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('Level-2-Core-DOM-createDocType')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=525"/> |
| </metadata> |
| <var name="publicId" type="DOMString" value='"http://www.example.com/"'/> |
| <var name="systemId" type="DOMString" value='"myDoc.dtd"'/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <implementation var="domImpl"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createDocumentType obj="domImpl" var="docType" qualifiedName='""' publicId="publicId" systemId="systemId"/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createElementNS01.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createElementNS01"> |
| <metadata> |
| <title>createElementNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "createElementNS(namespaceURI,qualifiedName)" method for a |
| Document should raise NAMESPACE_ERR DOMException if |
| qualifiedName is malformed. |
| Invoke method createElementNS(namespaceURI,qualifiedName) on |
| the XMLNS Document with namespaceURI being the literal string |
| "http://www.ecommerce.org/", and qualifiedName as "prefix::local". |
| Method should raise NAMESPACE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrElNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-DocCrElNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.ecommerce.org/""/> |
| <var name="malformedName" type="DOMString" value=""prefix::local""/> |
| <var name="doc" type="Document"/> |
| <var name="newElement" type="Element"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createElementNS obj="doc" var="newElement" namespaceURI="namespaceURI" qualifiedName="malformedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createElementNS02.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createElementNS02"> |
| <metadata> |
| <title>createElementNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "createElementNS(namespaceURI,qualifiedName)" method for a |
| Document should raise NAMESPACE_ERR DOMException if |
| qualifiedName has a prefix and namespaceURI is null. |
| Invoke method createElementNS(namespaceURI,qualifiedName) on this document |
| with namespaceURI being null and qualifiedName being "elem:attr1". |
| Method should raise NAMESPACE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrElNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-DocCrElNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" isNull="true"/> |
| <var name="qualifiedName" type="DOMString" value=""prefix:local""/> |
| <var name="doc" type="Document"/> |
| <var name="newElement" type="Element"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createElementNS obj="doc" var="newElement" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createElementNS03.xml.unknown |
|---|
| 0,0 → 1,80 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createElementNS03"> |
| <metadata> |
| <title>createElementNS03</title> |
| <creator>NIST</creator> |
| <description> |
| The "createElementNS(namespaceURI,qualifiedName)" method for a |
| Document should raise INVALID_CHARACTER_ERR DOMException if |
| qualifiedName contains an illegal character. |
| Invoke method createElementNS(namespaceURI,qualifiedName) on this document |
| with qualifiedName containing an illegal character from illegalChars[]. |
| Method should raise INVALID_CHARACTER_ERR DOMException for all characters |
| in illegalChars[]. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrElNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-DocCrElNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.wedding.com/""/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <var name="done" type="boolean"/> |
| <var name="newElement" type="Element"/> |
| <var name="charact" type="DOMString"/> |
| <var name="illegalQNames" type="List"> |
| <member>"person:{"</member> |
| <member>"person:}"</member> |
| <member>"person:~"</member> |
| <member>"person:'"</member> |
| <member>"person:!"</member> |
| <member>"person:@"</member> |
| <member>"person:#"</member> |
| <member>"person:$"</member> |
| <member>"person:%"</member> |
| <member>"person:^"</member> |
| <member>"person:&"</member> |
| <member>"person:*"</member> |
| <member>"person:("</member> |
| <member>"person:)"</member> |
| <member>"person:+"</member> |
| <member>"person:="</member> |
| <member>"person:["</member> |
| <member>"person:]"</member> |
| <member>"person:\\"</member> |
| <member>"person:/"</member> |
| <member>"person:;"</member> |
| <member>"person:`"</member> |
| <member>"person:<"</member> |
| <member>"person:>"</member> |
| <member>"person:,"</member> |
| <member>"person:a "</member> |
| <member>"person:\""</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <for-each collection="illegalQNames" member="qualifiedName"> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createElementNS obj="doc" var="newElement" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createElementNS04.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createElementNS04"> |
| <metadata> |
| <title>createElementNS04</title> |
| <creator>NIST</creator> |
| <description> |
| The "createElementNS(namespaceURI,qualifiedName") method for |
| a Document should raise NAMESPACE_ERR DOMException if the |
| qualifiedName has an "xml" prefix and the namespaceURI is different |
| from http://www.w3.org/XML/1998/namespace". |
| Invoke method createElementNS(namespaceURI,qualifiedName) on this document |
| with qualifiedName being "xml:element1" and namespaceURI equals the string |
| "http://www.w3.org/XML/1997/namespace" (which differs from the required |
| string "http://www.w3.org/XML/1998/namespace"). |
| Method should raise NAMESPACE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrElNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-DocCrElNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.w3.org/XML/1998/namespaces""/> |
| <var name="qualifiedName" type="DOMString" value=""xml:element1""/> |
| <var name="doc" type="Document"/> |
| <var name="newElement" type="Element"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createElementNS obj="doc" var="newElement" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createElementNS05.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createElementNS05"> |
| <metadata> |
| <title>createElementNS05</title> |
| <creator>NIST</creator> |
| <description> |
| The "createElementNS(namespaceURI,qualifiedName)" method for a |
| Document should return a new Element object given that all parameters |
| are valid and correctly formed. |
| Invoke method createElementNS(namespaceURI,qualifiedName on this document |
| with namespaceURI as "http://www.nist.gov" and qualifiedName as "gov:faculty". |
| Method should return a new Element object whose name is "gov:faculty". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-104682815"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="qualifiedName" type="DOMString" value=""gov:faculty""/> |
| <var name="doc" type="Document"/> |
| <var name="newElement" type="Element"/> |
| <var name="elementName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createElementNS obj="doc" var="newElement" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <tagName obj="newElement" var="elementName"/> |
| <assertEquals actual="elementName" expected="qualifiedName" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/createElementNS06.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createElementNS06"> |
| <metadata> |
| <title>createElementNS06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Document.createElementNS with an empty qualified name should cause an INVALID_CHARACTER_ERR. |
| </description> |
| <date qualifier="created">2004-03-09</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrElNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-DocCrElNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=525"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value='"http://www.example.com/"'/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <var name="done" type="boolean"/> |
| <var name="newElement" type="Element"/> |
| <var name="charact" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <createElementNS obj="doc" var="newElement" namespaceURI="namespaceURI" qualifiedName='""'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateattributeNS01.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateattributeNS01"> |
| <metadata> |
| <title>documentcreateattributeNS01</title> |
| <creator>IBM</creator> |
| <description> |
| The method createAttributeNS creates an attribute of the given qualified name and namespace URI |
| Invoke the createAttributeNS method on this Document object with a null |
| namespaceURI, and a qualifiedName without a prefix. This should return a valid Attr |
| node object. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attribute" type="Attr"/> |
| <var name="namespaceURI" type="DOMString" isNull="true"/> |
| <var name="qualifiedName" type="DOMString" value=""test""/> |
| <var name="name" type="DOMString"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createAttributeNS obj="doc" var="attribute" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <nodeName var="nodeName" obj="attribute" /> |
| <nodeValue var="nodeValue" obj="attribute" /> |
| <assertEquals actual="nodeName" expected='"test"' id="documentcreateattributeNS01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateattributeNS02.xml.unknown |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateattributeNS02"> |
| <metadata> |
| <title>documentcreateattributeNS02</title> |
| <creator>IBM</creator> |
| <description> |
| The method createAttributeNS creates an attribute of the given qualified name and namespace URI |
| Invoke the createAttributeNS method on this Document object with a valid values for |
| namespaceURI, and a qualifiedName as below. This should return a valid Attr node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attribute1" type="Attr"/> |
| <var name="attribute2" type="Attr"/> |
| <var name="name" type="DOMString"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createAttributeNS obj="doc" var="attribute1" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:xml"'/> |
| <name var="name" obj="attribute1" interface="Attr"/> |
| <nodeName var="nodeName" obj="attribute1" /> |
| <nodeValue var="nodeValue" obj="attribute1" /> |
| <prefix var="prefix" obj="attribute1" /> |
| <namespaceURI var="namespaceURI" obj="attribute1" /> |
| <assertEquals actual="name" expected='"xml:xml"' id="documentcreateattributeNS02_att1_name" ignoreCase="false"/> |
| <assertEquals actual="nodeName" expected='"xml:xml"' id="documentcreateattributeNS02_att1_nodeName" ignoreCase="false"/> |
| <assertEquals actual="nodeValue" expected='""' id="documentcreateattributeNS02_att1_nodeValue" ignoreCase="false"/> |
| <assertEquals actual="prefix" expected='"xml"' id="documentcreateattributeNS02_att1_prefix" ignoreCase="false"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.w3.org/XML/1998/namespace"' id="documentcreateattributeNS02_att1_namespaceURI" ignoreCase="false"/> |
| <createAttributeNS obj="doc" var="attribute2" namespaceURI='"http://www.w3.org/2000/xmlns/"' qualifiedName='"xmlns"'/> |
| <name var="name" obj="attribute2" interface="Attr"/> |
| <nodeName var="nodeName" obj="attribute2" /> |
| <nodeValue var="nodeValue" obj="attribute2" /> |
| <prefix var="prefix" obj="attribute2"/> |
| <namespaceURI var="namespaceURI" obj="attribute2"/> |
| <assertEquals actual="name" expected='"xmlns"' id="documentcreateattributeNS02_att2_name" ignoreCase="false"/> |
| <assertEquals actual="nodeName" expected='"xmlns"' id="documentcreateattributeNS02_att2_nodeName" ignoreCase="false"/> |
| <assertEquals actual="nodeValue" expected='""' id="documentcreateattributeNS02_att2_nodeValue" ignoreCase="false"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.w3.org/2000/xmlns/"' id="documentcreateattributeNS02_att2_namespaceURI" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateattributeNS03.xml.unknown |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateattributeNS03"> |
| <metadata> |
| <title>documentcreateattributeNS03</title> |
| <creator>IBM</creator> |
| <description> |
| The method createAttributeNS raises an INVALID_CHARACTER_ERR if the specified |
| qualified name contains an illegal character |
| Invoke the createAttributeNS method on this Document object with a valid value for |
| namespaceURI, and qualifiedNames that contain illegal characters. Check if the an |
| INVALID_CHARACTER_ERR was thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attribute" type="Attr"/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.w3.org/DOM/Test/Level2""/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="qualifiedNames" type="List"> |
| <member>"/"</member> |
| <member>"//"</member> |
| <member>"\\"</member> |
| <member>";"</member> |
| <member>"&"</member> |
| <member>"*"</member> |
| <member>"]]"</member> |
| <member>">"</member> |
| <member>"<"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <for-each collection="qualifiedNames" member="qualifiedName"> |
| <assertDOMException id="documentcreateattributeNS03"> |
| <INVALID_CHARACTER_ERR> |
| <createAttributeNS obj="doc" var="attribute" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateattributeNS04.xml.unknown |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateattributeNS04"> |
| <metadata> |
| <title>documentcreateattributeNS04</title> |
| <creator>IBM</creator> |
| <description> |
| The method createAttributeNS raises a NAMESPACE_ERR if the specified qualified name |
| is malformed. |
| Invoke the createAttributeNS method on this Document object with a valid value for |
| namespaceURI, and malformed qualifiedNames. Check if the a NAMESPACE_ERR was thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attribute" type="Attr"/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.w3.org/DOM/Test/Level2""/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="qualifiedNames" type="List"> |
| <member>"_:"</member> |
| <member>":0a"</member> |
| <member>":"</member> |
| <member>"a:b:c"</member> |
| <member>"_::a"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <for-each collection="qualifiedNames" member="qualifiedName"> |
| <assertDOMException id="documentcreateattributeNS04"> |
| <NAMESPACE_ERR> |
| <createAttributeNS obj="doc" var="attribute" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateattributeNS05.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateattributeNS05"> |
| <metadata> |
| <title>documentcreateattributeNS05</title> |
| <creator>IBM</creator> |
| <description> |
| The method createAttributeNS raises a NAMESPACE_ERR if the qualifiedName has a prefix and |
| the namespaceURI is null. |
| Invoke the createAttributeNS method on a new Document object with a null value for |
| namespaceURI, and a valid qualifiedName. Check if a NAMESPACE_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="attribute" type="Attr"/> |
| <var name="namespaceURI" type="DOMString" isNull="true"/> |
| <var name="qualifiedName" type="DOMString" value='"abc:def"'/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom:doc"' doctype="docType"/> |
| <assertDOMException id="documentcreateattributeNS05"> |
| <NAMESPACE_ERR> |
| <createAttributeNS obj="newDoc" var="attribute" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException></test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateattributeNS06.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateattributeNS06"> |
| <metadata> |
| <title>documentcreateattributeNS06</title> |
| <creator>IBM</creator> |
| <description> |
| The method createAttributeNS raises a NAMESPACE_ERR if the qualifiedName has a prefix that |
| is "xml" and the namespaceURI is different from "http://www.w3.org/XML/1998/namespace". |
| Invoke the createAttributeNS method on a new DOMImplementation object with the qualifiedName |
| as xml:root and namespaceURI as http://www.w3.org/XML/1998 /namespace. |
| Check if the NAMESPACE_ERR exception is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="attribute" type="Attr"/> |
| <var name="namespaceURI" type="DOMString" value='"http://www.w3.org/XML/1998 /namespace"'/> |
| <var name="qualifiedName" type="DOMString" value='"xml:root"'/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom:doc"' doctype="docType"/> |
| <assertDOMException id="documentcreateattributeNS06"> |
| <NAMESPACE_ERR> |
| <createAttributeNS obj="newDoc" var="attribute" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException></test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateattributeNS07.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateattributeNS07"> |
| <metadata> |
| <title>documentcreateattributeNS07</title> |
| <creator>IBM</creator> |
| <description> |
| The method createAttributeNS raises a NAMESPACE_ERR if the qualifiedName is xmlns and |
| the namespaceURI is different from http://www.w3.org/2000/xmlns |
| Invoke the createAttributeNS method on this DOMImplementation object with |
| the qualifiedName as xmlns and namespaceURI as http://www.W3.org/2000/xmlns. |
| Check if the NAMESPACE_ERR exception is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attribute" type="Attr"/> |
| <var name="namespaceURI" type="DOMString" value='"http://www.W3.org/2000/xmlns"'/> |
| <var name="qualifiedName" type="DOMString" value='"xmlns"'/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <assertDOMException id="documentcreateattributeNS07"> |
| <NAMESPACE_ERR> |
| <createAttributeNS obj="doc" var="attribute" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException></test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateelementNS01.xml.unknown |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateelementNS01"> |
| <metadata> |
| <title>documentcreateelementNS01</title> |
| <creator>IBM</creator> |
| <description> |
| The method createElementNS creates an element of the given valid qualifiedName and NamespaceURI. |
| Invoke the createElementNS method on this Document object with a valid namespaceURI |
| and qualifiedName. Check if a valid Element object is returned with the same node attributes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrElNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="namespaceURI" type="DOMString" value='"http://www.w3.org/DOM/Test/level2"'/> |
| <var name="qualifiedName" type="DOMString" value='"XML:XML"'/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nsURI" type="DOMString"/> |
| <var name="localName" type="DOMString"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="tagName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createElementNS obj="doc" var="element" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <nodeName var="nodeName" obj="element" /> |
| <namespaceURI var="nsURI" obj="element" /> |
| <localName var="localName" obj="element" /> |
| <prefix var="prefix" obj="element" /> |
| <tagName var="tagName" obj="element" /> |
| <assertEquals actual="nodeName" expected='"XML:XML"' id="documentcreateelementNS01_nodeName" ignoreCase="false"/> |
| <assertEquals actual="nsURI" expected='"http://www.w3.org/DOM/Test/level2"' id="documentcreateelementNS01_namespaceURI" ignoreCase="false"/> |
| <assertEquals actual="localName" expected='"XML"' id="documentcreateelementNS01_localName" ignoreCase="false"/> |
| <assertEquals actual="prefix" expected='"XML"' id="documentcreateelementNS01_prefix" ignoreCase="false"/> |
| <assertEquals actual="tagName" expected='"XML:XML"' id="documentcreateelementNS01_tagName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateelementNS02.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateelementNS02"> |
| <metadata> |
| <title>documentcreateelementNS02</title> |
| <creator>IBM</creator> |
| <description> |
| The method createElementNS creates an element of the given valid qualifiedName and NamespaceURI. |
| Invoke the createElementNS method on this Document object with null values for namespaceURI, |
| and a qualifiedName with an invalid character and check if an INVALID_CHARACTER_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrElNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="namespaceURI" type="DOMString" isNull="true"/> |
| <var name="qualifiedName" type="DOMString" value='"^^"' /> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <assertDOMException id="documentcreateelementNS02"> |
| <INVALID_CHARACTER_ERR> |
| <createElementNS obj="doc" var="element" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateelementNS05.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateelementNS05"> |
| <metadata> |
| <title>documentcreateelementNS05</title> |
| <creator>IBM</creator> |
| <description> |
| The method createElementNS raises a NAMESPACE_ERR if the qualifiedName has a prefix and |
| the namespaceURI is null. |
| Invoke the createElementNS method on a new Document object with a null value for |
| namespaceURI, and a valid qualifiedName. Check if a NAMESPACE_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrElNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="namespaceURI" type="DOMString" isNull="true"/> |
| <var name="qualifiedName" type="DOMString" value='"null:xml"'/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <assertDOMException id="documentcreateelementNS05"> |
| <NAMESPACE_ERR> |
| <createElementNS obj="doc" var="element" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException></test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentcreateelementNS06.xml.unknown |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentcreateelementNS06"> |
| <metadata> |
| <title>documentcreateelementNS06</title> |
| <creator>IBM</creator> |
| <description> |
| The method createElementNS raises a NAMESPACE_ERR if the qualifiedName |
| has a prefix that is "xml" and the namespaceURI is different |
| from http://www.w3.org/XML/1998/namespace |
| Invoke the createElementNS method on this DOMImplementation object with |
| the qualifiedName as xml:root and namespaceURI as http://www.w3.org/xml/1998/namespace |
| Check if the NAMESPACE_ERR exception is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-DocCrElNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="element" type="Element"/> |
| <var name="namespaceURI" type="DOMString" value='"http://www.w3.org/xml/1998/namespace "'/> |
| <var name="qualifiedName" type="DOMString" value='"xml:root"'/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom:doc"' doctype="docType"/> |
| <assertDOMException id="documentcreateelementNS06"> |
| <NAMESPACE_ERR> |
| <createElementNS obj="newDoc" var="element" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException></test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentgetelementbyid01.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentgetelementbyid01"> |
| <metadata> |
| <title>documentgetelementbyid01</title> |
| <creator>IBM</creator> |
| <description> |
| The method getElementById returns the element whose ID is given by elementId. |
| If not such element exists, returns null. |
| Invoke the getElementById method on this Document object with an invalid elementId. |
| This should return a null element. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBId"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="elementId" type="DOMString" value='"---"'/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementById var="element" obj="doc" elementId="elementId"/> |
| <assertNull actual="element" id="documentgetelementbyid01" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentgetelementsbytagnameNS01.xml.notimpl |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentgetelementsbytagnameNS01"> |
| <metadata> |
| <title>documentgetelementsbytagnameNS01</title> |
| <creator>IBM</creator> |
| <description> |
| The method getElementsByTagNameNS returns a NodeList of all the Elements with |
| a given local name and namespace URI in the order in which they are encountered |
| in a preorder traversal of the Document tree. |
| Invoke the getElementsByTagNameNS method on a new Document object with the values of |
| namespaceURI=* and localName=*. This should return a nodeList of 1 item. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="childList" type="NodeList"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="nullNS" qualifiedName='"root"' doctype="docType"/> |
| <getElementsByTagNameNS var="childList" obj="newDoc" namespaceURI ='"*"' localName ='"*"' interface="Document"/> |
| <assertSize size="1" collection="childList" id="documentgetelementsbytagnameNS01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentgetelementsbytagnameNS02.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentgetelementsbytagnameNS02"> |
| <metadata> |
| <title>documentgetelementsbytagnameNS02</title> |
| <creator>IBM</creator> |
| <description> |
| The method getElementsByTagNameNS returns a NodeList of all the Elements with |
| a given local name and namespace URI in the order in which they are encountered |
| in a preorder traversal of the Document tree. |
| Create a new element having a local name="employeeId" belonging to the namespace "test" |
| and append it to this document. Invoke the getElementsByTagNameNS method on a this |
| Document object with the values of namespaceURI=* and localName="elementId". This |
| should return a nodeList of 6 item. Check the length of the nodeList returned. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="element" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"test"' qualifiedName='"employeeId"'/> |
| <appendChild var="appendedChild" obj="docElem" newChild="element"/> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI ='"*"' localName ='"employeeId"' interface="Document"/> |
| <assertSize size="6" collection="childList" id="documentgetelementsbytagnameNS02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentgetelementsbytagnameNS03.xml.kfail |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentgetelementsbytagnameNS03"> |
| <metadata> |
| <title>documentgetelementsbytagnameNS03</title> |
| <creator>IBM</creator> |
| <description> |
| The method getElementsByTagNameNS returns a NodeList of all the Elements with |
| a given local name and namespace URI in the order in which they are encountered |
| in a preorder traversal of the Document tree. |
| Invoke the getElementsByTagNameNS method on a new Document object with the values of |
| namespaceURI=** and localName=**. This should return a nodeList of 0 items. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI ='"**"' localName ='"*"' interface="Document"/> |
| <assertSize size="0" collection="childList" id="documentgetelementsbytagnameNS03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentgetelementsbytagnameNS04.xml.kfail |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentgetelementsbytagnameNS04"> |
| <metadata> |
| <title>documentgetelementsbytagnameNS04</title> |
| <creator>IBM</creator> |
| <description> |
| The method getElementsByTagNameNS returns a NodeList of all the Elements with |
| a given local name and namespace URI in the order in which they are encountered |
| in a preorder traversal of the Document tree. |
| Invoke the getElementsByTagNameNS method on a new Document object with the values of |
| namespaceURI="null" and localName="0". This should return a nodeList of 0 items. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI ="nullNS" localName ='"0"' interface="Document"/> |
| <assertSize size="0" collection="childList" id="documentgetelementsbytagnameNS04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentgetelementsbytagnameNS05.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentgetelementsbytagnameNS05"> |
| <metadata> |
| <title>documentgetelementsbytagnameNS05</title> |
| <creator>IBM</creator> |
| <description> |
| The method getElementsByTagNameNS returns a NodeList of all the Elements with |
| a given local name and namespace URI in the order in which they are encountered |
| in a preorder traversal of the Document tree. |
| Invoke the getElementsByTagNameNS method on a this Document object with the |
| values of namespaceURI=null and localName="elementId". This |
| should return a nodeList of 0 item. Check the length of the nodeList returned. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI ='"null"' localName ='"elementId"' interface="Document"/> |
| <assertSize size="0" collection="childList" id="documentgetelementsbytagnameNS05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode01.xml.unknown |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode01"> |
| <metadata> |
| <title>documentimportnode01</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=true, import the attribute, "street" of the second |
| element node, from a list of nodes whose local names are "address" and namespaceURI |
| "http://www.nist.gov" into the same document. Check the parentNode, nodeName, |
| nodeType and nodeValue of the imported node to verify if it has been imported correctly. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="importedAttr" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="childList" obj="doc" localName='"address"' namespaceURI='"http://www.nist.gov"' interface="Document"/> |
| <item var="element" obj="childList" index="1" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="element" name='"street"'/> |
| <importNode var="importedAttr" obj="doc" importedNode="attr" deep="false"/> |
| <nodeName var="nodeName" obj="importedAttr"/> |
| <nodeValue var="nodeValue" obj="importedAttr"/> |
| <nodeType var="nodeType" obj="importedAttr"/> |
| <!-- Seems like this causes an xslt problem |
| <parentNode var="attrsParent" obj="importedAttr"/> |
| <assertNull actual="attrsParent" id="documentimportnode01_parentNull"/> |
| --> |
| <assertEquals expected='"street"' actual="nodeName" id="documentimportnode01_nodeName" ignoreCase="false"/> |
| <assertEquals expected="2" actual="nodeType" id="documentimportnode01_nodeType" ignoreCase="false"/> |
| <assertEquals expected='"Yes"' actual="nodeValue" id="documentimportnode01_nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode02.xml.unknown |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode02"> |
| <metadata> |
| <title>documentimportnode02</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=false, import the attribute, "emp:zone" of the |
| element node which is retreived by its elementId="CANADA", into the another document. |
| Check the parentNode, nodeName, nodeType and nodeValue of the imported node to |
| verify if it has been imported correctly. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docImported" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="importedAttr" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="addresses" type="NodeList"/> |
| <var name="attrsParent" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="docImported" href="staff" willBeModified="true"/> |
| <getElementsByTagNameNS var="addresses" obj="doc" interface="Document" namespaceURI='"http://www.nist.gov"' localName='"address"'/> |
| <item var="element" obj="addresses" interface="NodeList" index="1"/> |
| <getAttributeNodeNS var="attr" obj="element" namespaceURI='"http://www.nist.gov"' localName='"zone"'/> |
| <importNode var="importedAttr" obj="docImported" importedNode="attr" deep="false"/> |
| <nodeName var="nodeName" obj="importedAttr"/> |
| <nodeType var="nodeType" obj="importedAttr"/> |
| <nodeValue var="nodeValue" obj="importedAttr"/> |
| <parentNode var="attrsParent" obj="importedAttr" interface="Node"/> |
| <assertNull actual="attrsParent" id="documentimportnode02_parentNull"/> |
| <assertEquals expected='"emp:zone"' actual="nodeName" id="documentimportnode02_nodeName" ignoreCase="false"/> |
| <assertEquals expected="2" actual="nodeType" id="documentimportnode02_nodeType" ignoreCase="false"/> |
| <assertEquals expected='"CANADA"' actual="nodeValue" id="documentimportnode02_nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode03.xml.unknown |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode03"> |
| <metadata> |
| <title>documentimportnode03</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=false, import the default Attribute attribute, |
| "defaultAttr" of the second element node whose namespaceURI="http://www.nist.gov" and |
| localName="defaultAttr", into the same document. |
| Check the parentNode, nodeName, nodeType and nodeValue of the imported node to |
| verify if it has been imported correctly. </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="importedAttr" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="childList" obj="doc" localName='"employee"' namespaceURI='"http://www.nist.gov"' interface="Document"/> |
| <item var="element" obj="childList" index="1" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="element" name='"defaultAttr"'/> |
| <importNode var="importedAttr" obj="doc" importedNode="attr" deep="false"/> |
| <nodeName var="nodeName" obj="importedAttr"/> |
| <nodeValue var="nodeValue" obj="importedAttr"/> |
| <nodeType var="nodeType" obj="importedAttr"/> |
| <assertEquals expected='"defaultAttr"' actual="nodeName" id="documentimportnode03_nodeName" ignoreCase="false"/> |
| <assertEquals expected="2" actual="nodeType" id="documentimportnode03_nodeType" ignoreCase="false"/> |
| <assertEquals expected='"defaultVal"' actual="nodeValue" id="documentimportnode03_nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode04.xml.unknown |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode04"> |
| <metadata> |
| <title>documentimportnode04</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=true, import the default Attribute attribute, |
| "defaultAttr" of the second element node whose namespaceURI="http://www.nist.gov" and |
| localName="defaultAttr", into a new document. |
| Check the parentNode, nodeName, nodeType and nodeValue of the imported node to |
| verify if it has been imported correctly. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="importedAttr" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"l2:root"' doctype="docType"/> |
| <getElementsByTagNameNS var="childList" obj="doc" localName='"employee"' namespaceURI='"http://www.nist.gov"' interface="Document"/> |
| <item var="element" obj="childList" index="1" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="element" name='"defaultAttr"'/> |
| <importNode var="importedAttr" obj="newDoc" importedNode="attr" deep="true"/> |
| <nodeName var="nodeName" obj="importedAttr"/> |
| <nodeValue var="nodeValue" obj="importedAttr"/> |
| <nodeType var="nodeType" obj="importedAttr"/> |
| <assertEquals expected='"defaultAttr"' actual="nodeName" id="documentimportnode04_nodeName" ignoreCase="false"/> |
| <assertEquals expected="2" actual="nodeType" id="documentimportnode04_nodeType" ignoreCase="false"/> |
| <assertEquals expected='"defaultVal"' actual="nodeValue" id="documentimportnode04_nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode05.xml.unknown |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode05"> |
| <metadata> |
| <title>documentimportnode05</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=false, import a newly created attribute node, |
| into the another document. |
| Check the nodeName, nodeType and nodeValue namespaceURI of the imported node to |
| verify if it has been imported correctly. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docImported" type="Document"/> |
| <var name="attr" type="Attr"/> |
| <var name="importedAttr" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="docImported" href="staff" willBeModified="true"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"a_:b0"' /> |
| <importNode var="importedAttr" obj="docImported" importedNode="attr" deep="false"/> |
| <nodeName var="nodeName" obj="importedAttr"/> |
| <nodeValue var="nodeValue" obj="importedAttr"/> |
| <nodeType var="nodeType" obj="importedAttr"/> |
| <namespaceURI var="namespaceURI" obj="importedAttr"/> |
| <assertEquals expected='"a_:b0"' actual="nodeName" id="documentimportnode05_nodeName" ignoreCase="false"/> |
| <assertEquals expected="2" actual="nodeType" id="documentimportnode05_nodeType" ignoreCase="false"/> |
| <assertEquals expected='""' actual="nodeValue" id="documentimportnode05_nodeValue" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/DOM/Test"' actual="namespaceURI" id="documentimportnode05_namespaceURI" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode06.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode06"> |
| <metadata> |
| <title>documentimportnode06</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| A NOT_SUPPORTED_ERR is raised if the type of node being imported is |
| not supported |
| Using the method importNode with deep=false, try to import this document object to itself. |
| Since Document nodes cannot be imported, a NOT_SUPPORTED_ERR should be raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docImported" type="Document"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <importNode var="docImported" obj="doc" importedNode="doc" deep="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode07.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode07"> |
| <metadata> |
| <title>documentimportnode07</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| A NOT_SUPPORTED_ERR is raised if the type of node being imported is |
| not supported |
| Using the method importNode with deep=true, try to import this Document's |
| DocumentType object. Since DocumentType nodes cannot be imported, a |
| NOT_SUPPORTED_ERR should be raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="imported" type="Node"/> |
| <var name="docType" type="DocumentType"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <importNode var="imported" obj="doc" importedNode="docType" deep="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode08.xml.unknown |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode08"> |
| <metadata> |
| <title>documentimportnode08</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| A NOT_SUPPORTED_ERR is raised if the type of node being imported is |
| not supported |
| Using the method importNode with deep=true, try to import a newly created DOcumentType |
| node. Since DocumentType nodes cannot be imported, a NOT_SUPPORTED_ERR should be raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="imported" type="Node"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="docType" obj="domImpl" qualifiedName='"test:root"' publicId="nullNS" systemId="nullNS"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <importNode var="imported" obj="doc" importedNode="docType" deep="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode09.xml.unknown |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode09"> |
| <metadata> |
| <title>documentimportnode09</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=false, import a newly created DocumentFragment node |
| with the first address element from this Document appended to it into this document. |
| Since deep=false, an empty DocumentFragment should be returned |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="childList" type="NodeList"/> |
| <var name="success" type="boolean"/> |
| <var name="addressNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="importedDocFrag" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createDocumentFragment var="docFragment" obj="doc"/> |
| <getElementsByTagNameNS var="childList" obj="doc" localName='"address"' namespaceURI='"*"' interface="Document"/> |
| <item var="addressNode" obj="childList" index="0" interface="NodeList"/> |
| <appendChild var="appendedChild" obj="docFragment" newChild="addressNode"/> |
| <importNode var="importedDocFrag" obj="doc" importedNode="docFragment" deep="false"/> |
| <hasChildNodes var="success" obj="importedDocFrag"/> |
| <assertFalse actual="success" id="documentimportnode09"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode10.xml.unknown |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode10"> |
| <metadata> |
| <title>documentimportnode10</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=false, import a newly created DocumentFragment node |
| with the first address element from this Document appended to it into this document. |
| Since deep=true, a DocumentFragment with its child should be returned |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="childList" type="NodeList"/> |
| <var name="success" type="boolean"/> |
| <var name="addressNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="importedDocFrag" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createDocumentFragment var="docFragment" obj="doc"/> |
| <getElementsByTagNameNS var="childList" obj="doc" localName='"address"' namespaceURI='"*"' interface="Document"/> |
| <item var="addressNode" obj="childList" index="0" interface="NodeList"/> |
| <appendChild var="appendedChild" obj="docFragment" newChild="addressNode"/> |
| <importNode var="importedDocFrag" obj="doc" importedNode="docFragment" deep="true"/> |
| <hasChildNodes var="success" obj="importedDocFrag"/> |
| <assertTrue actual="success" id="documentimportnode10"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode11.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode11"> |
| <metadata> |
| <title>documentimportnode11</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=false, import this Document's documentElement |
| node. Verify if the node has been imported correctly by its nodeName atttribute and |
| if the original document is not altered by checking if hasChildNodes returns false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElement" type="Element"/> |
| <var name="imported" type="Node"/> |
| <var name="success" type="boolean"/> |
| <var name="nodeNameOrig" type="DOMString"/> |
| <var name="nodeNameImported" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <documentElement var="docElement" obj="doc"/> |
| <importNode var="imported" obj="doc" importedNode="docElement" deep="false"/> |
| <hasChildNodes var="success" obj="imported"/> |
| <assertFalse actual="success" id="documentimportnode11"/> |
| <nodeName var="nodeNameImported" obj="imported"/> |
| <nodeName var="nodeNameOrig" obj="docElement"/> |
| <assertEquals actual="nodeNameOrig" expected="nodeNameImported" id="documentimportnode11_NodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode12.xml.unknown |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode12"> |
| <metadata> |
| <title>documentimportnode12</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=true, import the first address element node of this |
| Document. Verify if the node has been imported correctly by checking the length of the |
| this elements childNode list before and after the import. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="imported" type="Node"/> |
| <var name="addressElem" type="Node"/> |
| <var name="addressElemChildren" type="NodeList"/> |
| <var name="importedChildren" type="NodeList"/> |
| <var name="addressElemLen" type="int"/> |
| <var name="importedLen" type="int"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="addressElem" obj="childList" index="0" interface="NodeList"/> |
| <importNode var="imported" obj="doc" importedNode="addressElem" deep="true"/> |
| <childNodes var="addressElemChildren" obj="addressElem"/> |
| <childNodes var="importedChildren" obj="imported"/> |
| <length var="addressElemLen" obj="addressElemChildren" interface="NodeList"/> |
| <length var="importedLen" obj="importedChildren" interface="NodeList"/> |
| <assertEquals actual="addressElemLen" expected="importedLen" id="documentimportnode12" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode13.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode13"> |
| <metadata> |
| <title>documentimportnode13</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=false, import the first employee element node of this |
| Document. Verify if the node has been imported correctly by checking the length of the |
| this elements childNode list before and after the import. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="imported" type="Node"/> |
| <var name="importedList" type="NodeList"/> |
| <var name="employeeElem" type="Node"/> |
| <var name="importedLen" type="int"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI='"*"' localName='"employee"' interface="Document"/> |
| <item var="employeeElem" obj="childList" index="0" interface="NodeList"/> |
| <importNode var="imported" obj="doc" importedNode="employeeElem" deep="false"/> |
| <childNodes var="importedList" obj="imported"/> |
| <length var="importedLen" obj="importedList" interface="NodeList"/> |
| <assertEquals expected="0" actual="importedLen" id="documentimportnode13" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode14.xml.unknown |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode14"> |
| <metadata> |
| <title>documentimportnode14</title> |
| <creator>IBM</creator> |
| <description> |
| Using the method importNode with deep=true, import the fourth employee element node of this |
| Document. Verify if the node has been imported correctly by checking |
| if the default attribute present on this node has not been imported |
| and an explicit attribute has been imported. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=402"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="childList" type="NodeList"/> |
| <var name="imported" type="Node"/> |
| <var name="employeeElem" type="Node"/> |
| <var name="attrNode" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <!-- willBeModified set to true just to be safe --> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI='"*"' localName='"employee"' interface="Document"/> |
| <item var="employeeElem" obj="childList" index="3" interface="NodeList"/> |
| <implementation var="domImpl"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="nullNS" qualifiedName='"staff"' doctype="nullDocType"/> |
| <importNode var="imported" obj="newDoc" importedNode="employeeElem" deep="true"/> |
| <getAttributeNodeNS var="attrNode" obj="imported" namespaceURI="nullNS" localName='"defaultAttr"'/> |
| <!-- default attribute should not be copied --> |
| <assertNull actual="attrNode" id="defaultAttrNotImported"/> |
| <!-- explicit attributes should be copied --> |
| <getAttributeNS var="attrValue" obj="imported" namespaceURI='"http://www.w3.org/2000/xmlns/"' localName='"emp"'/> |
| <assertEquals actual="attrValue" expected='"http://www.nist.gov"' |
| ignoreCase="false" id="explicitAttrImported"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode15.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode15"> |
| <metadata> |
| <title>documentimportnode15</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=true, import a newly created Text node for this |
| Document. Verify if the node has been imported correctly by checking the value of the |
| imported text node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docImp" type="Document"/> |
| <var name="textImport" type="Node"/> |
| <var name="textToImport" type="Node"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="docImp" href="staffNS" willBeModified="true"/> |
| <createTextNode var="textToImport" obj="doc" data='"Document.importNode test for a TEXT_NODE"'/> |
| <importNode var="textImport" obj="doc" importedNode="textToImport" deep="true"/> |
| <nodeValue var="nodeValue" obj="textImport"/> |
| <assertEquals expected='"Document.importNode test for a TEXT_NODE"' actual="nodeValue" id="documentimportnode15" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode17.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode17"> |
| <metadata> |
| <title>documentimportnode17</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=true, import a newly created Comment node for this |
| Document. Verify if the node has been imported correctly by checking the value of the |
| imported Comment node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docImp" type="Document"/> |
| <var name="commentImport" type="Node"/> |
| <var name="commentToImport" type="Node"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="docImp" href="staffNS" willBeModified="true"/> |
| <createComment var="commentToImport" obj="doc" data='"Document.importNode test for a COMMENT_NODE"'/> |
| <importNode var="commentImport" obj="doc" importedNode="commentToImport" deep="true"/> |
| <nodeValue var="nodeValue" obj="commentImport"/> |
| <assertEquals expected='"Document.importNode test for a COMMENT_NODE"' actual="nodeValue" id="documentimportnode17" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode18.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode18"> |
| <metadata> |
| <title>documentimportnode18</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=true, import a newly created PI node for this |
| Document. Verify if the node has been imported correctly by checking the PITarget and |
| PIData values of the imported PI node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docImp" type="Document"/> |
| <var name="piImport" type="ProcessingInstruction"/> |
| <var name="piToImport" type="ProcessingInstruction"/> |
| <var name="piData" type="DOMString"/> |
| <var name="piTarget" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="docImp" href="staffNS" willBeModified="true"/> |
| <createProcessingInstruction var="piToImport" obj="doc" target='"Target"' data='"Data"'/> |
| <importNode var="piImport" obj="doc" importedNode="piToImport" deep="false"/> |
| <target var="piTarget" obj="piImport" interface="ProcessingInstruction"/> |
| <data var="piData" obj="piImport" interface="ProcessingInstruction"/> |
| <assertEquals expected='"Target"' actual="piTarget" id="documentimportnode18_Target" ignoreCase="false"/> |
| <assertEquals expected='"Data"' actual="piData" id="documentimportnode18_Data" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode19.xml.unknown |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode19"> |
| <metadata> |
| <title>documentimportnode19</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=true/false, import a entity nodes ent2 and ent6 |
| from this document to a new document object. Verify if the nodes have been |
| imported correctly by checking the nodeNames of the imported nodes and public and system ids. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docTypeNull" type="DocumentType" isNull="true"/> |
| <var name="docImp" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="nodeMap" type="NamedNodeMap"/> |
| <var name="entity2" type="Entity"/> |
| <var name="entity6" type="Entity"/> |
| <var name="entityImp2" type="Entity"/> |
| <var name="entityImp6" type="Entity"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="systemId" type="DOMString"/> |
| <var name="notationName" type="DOMString"/> |
| <var name="nodeNameImp" type="DOMString"/> |
| <var name="systemIdImp" type="DOMString"/> |
| <var name="notationNameImp" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <implementation var="domImpl" obj="doc" /> |
| <doctype var="docType" obj="doc"/> |
| <createDocument var="docImp" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"a:b"' doctype="docTypeNull"/> |
| <entities var="nodeMap" obj="docType"/> |
| <assertNotNull actual="nodeMap" id="entitiesNotNull"/> |
| <getNamedItem var="entity2" obj="nodeMap" name='"ent2"'/> |
| <getNamedItem var="entity6" obj="nodeMap" name='"ent6"'/> |
| <importNode var="entityImp2" obj="docImp" importedNode="entity2" deep="false"/> |
| <importNode var="entityImp6" obj="docImp" importedNode="entity6" deep="true"/> |
| <nodeName var="nodeName" obj="entity2" /> |
| <nodeName var="nodeNameImp" obj="entityImp2" /> |
| <assertEquals expected="nodeName" actual="nodeNameImp" id="documentimportnode19_Ent2NodeName" ignoreCase="false"/> |
| <nodeName var="nodeName" obj="entity6" /> |
| <nodeName var="nodeNameImp" obj="entityImp6" /> |
| <assertEquals expected="nodeName" actual="nodeNameImp" id="documentimportnode19_Ent6NodeName" ignoreCase="false"/> |
| <systemId var="systemId" obj="entity2" interface="Entity"/> |
| <systemId var="systemIdImp" obj="entityImp2" interface="Entity"/> |
| <assertEquals expected="systemId" actual="systemIdImp" id="documentimportnode19_Ent2SystemId" ignoreCase="false"/> |
| <systemId var="systemId" obj="entity6" interface="Entity"/> |
| <systemId var="systemIdImp" obj="entityImp6" interface="Entity"/> |
| <assertEquals expected="systemId" actual="systemIdImp" id="documentimportnode19_Ent6SystemId" ignoreCase="false"/> |
| <notationName var="notationName" obj="entity2" interface="Entity"/> |
| <notationName var="notationNameImp" obj="entityImp2" interface="Entity"/> |
| <assertEquals expected="notationName" actual="notationNameImp" id="documentimportnode19_Ent2NotationName" ignoreCase="false"/> |
| <notationName var="notationName" obj="entity6" interface="Entity"/> |
| <notationName var="notationNameImp" obj="entityImp6" interface="Entity"/> |
| <assertEquals expected="notationName" actual="notationNameImp" id="documentimportnode19_Ent6NotationName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode20.xml.unknown |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode20"> |
| <metadata> |
| <title>documentimportnode20</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=true, import a entity node ent4 |
| from this document to a new document object. The replacement text of this entity is an element |
| node, a cdata node and a pi. Verify if the nodes have been |
| imported correctly by checking the nodeNames of the imported element node, the data for the |
| cdata nodes and the PItarget and PIData for the pi nodes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="docImp" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="docTypeNull" type="DocumentType" isNull="true"/> |
| <var name="nodeMap" type="NamedNodeMap"/> |
| <var name="entity4" type="Entity"/> |
| <var name="entityImp4" type="Entity"/> |
| <var name="element" type="Element"/> |
| <var name="cdata" type="CharacterData"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="childList" type="NodeList"/> |
| <var name="elemchildList" type="NodeList"/> |
| <var name="ent4Name" type="DOMString"/> |
| <var name="ent4ImpName" type="DOMString"/> |
| <var name="cdataVal" type="DOMString"/> |
| <var name="piTargetVal" type="DOMString"/> |
| <var name="piDataVal" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <implementation var="domImpl" obj="doc" /> |
| <doctype var="docType" obj="doc"/> |
| <createDocument var="docImp" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"a:b"' doctype="docTypeNull"/> |
| <entities var="nodeMap" obj="docType"/> |
| <getNamedItem var="entity4" obj="nodeMap" name='"ent4"'/> |
| <importNode var="entityImp4" obj="docImp" importedNode="entity4" deep="true"/> |
| <childNodes var="childList" obj="entityImp4" /> |
| <item var="element" obj="childList" index="0" interface="NodeList"/> |
| <childNodes var="elemchildList" obj="element"/> |
| <item var="cdata" obj="elemchildList" index="0" interface="NodeList"/> |
| <item var="pi" obj="childList" index="1" interface="NodeList"/> |
| <nodeName var="ent4Name" obj="entity4"/> |
| <nodeName var="ent4ImpName" obj="entityImp4"/> |
| <data var="cdataVal" obj="cdata" interface="CharacterData"/> |
| <target var="piTargetVal" obj="pi" interface="ProcessingInstruction"/> |
| <data var="piDataVal" obj="pi" interface="ProcessingInstruction"/> |
| <assertEquals expected="ent4Name" actual="ent4ImpName" id="documentimportnode20_Ent4NodeName" ignoreCase="false"/> |
| <assertEquals expected='"Element data"' actual="cdataVal" id="documentimportnode20_Cdata" ignoreCase="false"/> |
| <assertEquals expected='"PItarget"' actual="piTargetVal" id="documentimportnode20_PITarget" ignoreCase="false"/> |
| <assertEquals expected='"PIdata"' actual="piDataVal" id="documentimportnode20_PIData" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode21.xml.unknown |
|---|
| 0,0 → 1,91 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode21"> |
| <metadata> |
| <title>documentimportnode21</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=true, retreive the entity refs present in the |
| second element node whose tagName is address and import these nodes into another document. |
| Verify if the nodes have been imported correctly by checking the nodeNames of the |
| imported nodes, since they are imported into a new document which doesnot have thes defined, |
| the imported nodes should not have any children. |
| Now import the entityRef nodes into the same document and verify if the nodes have been |
| imported correctly by checking the nodeNames of the imported nodes, and by checking the |
| value of the replacement text of the imported nodes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="docTypeNull" type="DocumentType" isNull="true"/> |
| <var name="docImp" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="addressChildList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="entRef2" type="EntityReference"/> |
| <var name="entRefImp2" type="EntityReference"/> |
| <var name="entRef3" type="EntityReference"/> |
| <var name="entRefImp3" type="EntityReference"/> |
| <var name="nodeName2" type="DOMString"/> |
| <var name="nodeName3" type="DOMString"/> |
| <var name="nodeNameImp2" type="DOMString"/> |
| <var name="nodeNameImp3" type="DOMString"/> |
| <var name="nodes" type="NodeList"/> |
| <var name="nodeImp3" type="Node"/> |
| <var name="nodeImp2" type="Node"/> |
| <var name="nodeValueImp2" type="DOMString"/> |
| <var name="nodeValueImp3" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <implementation var="domImpl" obj="doc" /> |
| <createDocument var="docImp" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"a:b"' doctype="docTypeNull"/> |
| <getElementsByTagName var="addressList" obj="doc" tagname='"address"' interface="Document"/> |
| <item var="element" obj="addressList" index="1" interface="NodeList"/> |
| <childNodes var="addressChildList" obj="element"/> |
| <item var="entRef2" obj="addressChildList" index="0" interface="NodeList"/> |
| <item var="entRef3" obj="addressChildList" index="2" interface="NodeList"/> |
| <importNode var="entRefImp2" obj="docImp" importedNode="entRef2" deep="true"/> |
| <importNode var="entRefImp3" obj="docImp" importedNode="entRef3" deep="false"/> |
| <nodeName var="nodeName2" obj="entRef2"/> |
| <nodeName var="nodeName3" obj="entRef3"/> |
| <nodeName var="nodeNameImp2" obj="entRefImp2"/> |
| <nodeName var="nodeNameImp3" obj="entRefImp3"/> |
| <assertEquals expected="nodeName2" actual="nodeNameImp2" id="documentimportnode21_Ent2NodeName" ignoreCase="false"/> |
| <assertEquals expected="nodeName3" actual="nodeNameImp3" id="documentimportnode21_Ent3NodeName" ignoreCase="false"/> |
| <importNode var="entRefImp2" obj="doc" importedNode="entRef2" deep="true"/> |
| <importNode var="entRefImp3" obj="doc" importedNode="entRef3" deep="false"/> |
| <childNodes var="nodes" obj="entRefImp2" interface="Node"/> |
| <item var="nodeImp2" obj="nodes" index="0" interface="NodeList"/> |
| <nodeValue var="nodeValueImp2" obj="nodeImp2"/> |
| <childNodes var="nodes" obj="entRefImp3" interface="Node"/> |
| <item var="nodeImp3" obj="nodes" index="0" interface="NodeList"/> |
| <nodeValue var="nodeValueImp3" obj="nodeImp3"/> |
| <assertEquals actual="nodeValueImp2" expected='"1900 Dallas Road"' id="documentimportnode21_Ent2NodeValue" ignoreCase="false"/> |
| <assertEquals actual="nodeValueImp3" expected='"Texas"' id="documentimportnode21_Ent3Nodevalue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documentimportnode22.xml.unknown |
|---|
| 0,0 → 1,92 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documentimportnode22"> |
| <metadata> |
| <title>documentimportnode21</title> |
| <creator>IBM</creator> |
| <description> |
| The importNode method imports a node from another document to this document. |
| The returned node has no parent; (parentNode is null). The source node is not |
| altered or removed from the original document but a new copy of the source node |
| is created. |
| Using the method importNode with deep=true/false, import two notaiton nodes into the |
| same and different documnet objects. In each case check if valid public and systemids |
| are returned if any and if none, check if a null value was returned. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docTypeNull" type="DocumentType" isNull="true"/> |
| <var name="docImp" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="nodeMap" type="NamedNodeMap"/> |
| <var name="notation1" type="Notation"/> |
| <var name="notation2" type="Notation"/> |
| <var name="notationImp1" type="Notation"/> |
| <var name="notationImp2" type="Notation"/> |
| <var name="notationImpNew1" type="Notation"/> |
| <var name="notationImpNew2" type="Notation"/> |
| <var name="publicId1" type="DOMString"/> |
| <var name="publicId1Imp" type="DOMString"/> |
| <var name="publicId1NewImp" type="DOMString"/> |
| <var name="publicId2Imp" type="DOMString"/> |
| <var name="publicId2NewImp" type="DOMString"/> |
| <var name="systemId1Imp" type="DOMString"/> |
| <var name="systemId1NewImp" type="DOMString"/> |
| <var name="systemId2" type="DOMString"/> |
| <var name="systemId2Imp" type="DOMString"/> |
| <var name="systemId2NewImp" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <implementation var="domImpl" obj="doc" /> |
| <doctype var="docType" obj="doc"/> |
| <createDocument var="docImp" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"a:b"' doctype="docTypeNull"/> |
| <notations var="nodeMap" obj="docType"/> |
| <assertNotNull actual="nodeMap" id="notationsNotNull"/> |
| <getNamedItem var="notation1" obj="nodeMap" name='"notation1"'/> |
| <getNamedItem var="notation2" obj="nodeMap" name='"notation2"'/> |
| <importNode var="notationImp1" obj="doc" importedNode="notation1" deep="true"/> |
| <importNode var="notationImp2" obj="doc" importedNode="notation2" deep="false"/> |
| <importNode var="notationImpNew1" obj="docImp" importedNode="notation1" deep="false"/> |
| <importNode var="notationImpNew2" obj="docImp" importedNode="notation2" deep="true"/> |
| <publicId var="publicId1" obj="notation1" interface="Notation"/> |
| <publicId var="publicId1Imp" obj="notation1" interface="Notation"/> |
| <publicId var="publicId1NewImp" obj="notation1" interface="Notation"/> |
| <systemId var="systemId1Imp" obj="notation1" interface="Notation"/> |
| <systemId var="systemId1NewImp" obj="notation1" interface="Notation"/> |
| <publicId var="publicId2Imp" obj="notation2" interface="Notation"/> |
| <publicId var="publicId2NewImp" obj="notation2" interface="Notation"/> |
| <systemId var="systemId2" obj="notation2" interface="Notation"/> |
| <systemId var="systemId2Imp" obj="notation2" interface="Notation"/> |
| <systemId var="systemId2NewImp" obj="notation2" interface="Notation"/> |
| <assertEquals expected="publicId1" actual="publicId1Imp" id="documentimportnode22_N1PID" ignoreCase="false"/> |
| <assertEquals expected="publicId1" actual="publicId1NewImp" id="documentimportnode22_N1NPID" ignoreCase="false"/> |
| <assertNull actual="systemId1Imp" id="documentimportnode22_N1SID"/> |
| <assertNull actual="systemId1NewImp" id="documentimportnode22_N1NSID" /> |
| <assertEquals expected="systemId2" actual="systemId2Imp" id="documentimportnode22_N2SID" ignoreCase="false"/> |
| <assertEquals expected="systemId2" actual="systemId2NewImp" id="documentimportnode22_N2NSID" ignoreCase="false"/> |
| <assertNull actual="publicId2Imp" id="documentimportnode22_N2PID"/> |
| <assertNull actual="publicId2Imp" id="documentimportnode22_N2NPID"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documenttypeinternalSubset01.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documenttypeinternalSubset01"> |
| <metadata> |
| <title>documenttypeinternalSubset01</title> |
| <creator>IBM</creator> |
| <description> |
| The method getInternalSubset() returns the internal subset as a string. |
| Create a new DocumentType node with null values for publicId and systemId. |
| Verify that its internal subset is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-Core-DocType-internalSubset"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="internal" type="DOMString"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="docType" obj="domImpl" qualifiedName='"l2:root"' publicId="nullNS" systemId="nullNS" /> |
| <internalSubset var="internal" obj="docType"/> |
| <assertNull actual="internal" id="internalSubsetNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documenttypepublicid01.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documenttypepublicid01"> |
| <metadata> |
| <title>documenttypepublicid01</title> |
| <creator>IBM</creator> |
| <description> |
| The method getInternalSubset() returns the public identifier of the external subset. |
| Create a new DocumentType node with the value "PUB" for its publicId. |
| Check the value of the publicId attribute using getPublicId(). |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-Core-DocType-publicId"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="publicId" type="DOMString"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="docType" obj="domImpl" qualifiedName='"l2:root"' publicId='"PUB"' systemId="nullNS" /> |
| <publicId var="publicId" obj="docType" interface="DocumentType"/> |
| <assertEquals actual="publicId" expected='"PUB"' id="documenttypepublicid01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/documenttypesystemid01.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="documenttypesystemid01"> |
| <metadata> |
| <title>documenttypesystemid01</title> |
| <creator>IBM</creator> |
| <description> |
| The method getInternalSubset() returns the public identifier of the external subset. |
| Create a new DocumentType node with the value "SYS" for its systemId and PUB for |
| its publicId. Check the value of the systemId and pbulicId attributes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-Core-DocType-systemId"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="publicId" type="DOMString"/> |
| <var name="systemId" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="docType" obj="domImpl" qualifiedName='"l2:root"' publicId='"PUB"' systemId='"SYS"' /> |
| <publicId var="publicId" obj="docType" interface="DocumentType"/> |
| <systemId var="systemId" obj="docType" interface="DocumentType"/> |
| <assertEquals actual="publicId" expected='"PUB"' id="documenttypepublicid01" ignoreCase="false"/> |
| <assertEquals actual="systemId" expected='"SYS"' id="documenttypesystemid01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationcreatedocument03.xml.unknown |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="domimplementationcreatedocument03"> |
| <metadata> |
| <title>domimplementationcreatedocument03</title> |
| <creator>IBM</creator> |
| <description> |
| The createDocument method with valid arguments, should create a DOM Document of |
| the specified type. |
| Call the createDocument on this DOMImplementation with |
| createDocument ("http://www.w3.org/DOMTest/L2",see the array below for valid QNames,null). |
| Check if the returned Document object is is empty with no Document Element. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.w3.org/DOMTest/L2""/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="qualifiedNames" type="List"> |
| <member>"_:_"</member> |
| <member>"_:h0"</member> |
| <member>"_:test"</member> |
| <member>"l_:_"</member> |
| <member>"ns:_0"</member> |
| <member>"ns:a0"</member> |
| <member>"ns0:test"</member> |
| <member>"a.b:c"</member> |
| <member>"a-b:c"</member> |
| <member>"a-b:c"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <for-each collection="qualifiedNames" member="qualifiedName"> |
| <createDocument obj="domImpl" var="newDoc" namespaceURI="namespaceURI" qualifiedName="qualifiedName" doctype="docType"/> |
| <assertNotNull actual="newDoc" id="domimplementationcreatedocument03"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationcreatedocument04.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="domimplementationcreatedocument04"> |
| <metadata> |
| <title>domimplementationcreatedocument04</title> |
| <creator>IBM</creator> |
| <description> |
| The createDocument method should throw a NAMESPACE_ERR if the qualifiedName has |
| a prefix and the namespaceURI is null. |
| Call the createDocument on this DOMImplementation with null namespaceURI and a |
| qualifiedName that has a namespace prefix using this DOMImplementation. |
| Check if the NAMESPACE_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="namespaceURI" type="DOMString" isNull="true"/> |
| <var name="qualifiedName" type="DOMString" value=""dom:root""/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <assertDOMException id="domimplementationcreatedocument04"> |
| <NAMESPACE_ERR> |
| <createDocument obj="domImpl" var="newDoc" namespaceURI="namespaceURI" qualifiedName="qualifiedName" doctype="docType"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationcreatedocument05.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="domimplementationcreatedocument05"> |
| <metadata> |
| <title>domimplementationcreatedocument05</title> |
| <creator>IBM</creator> |
| <description> |
| The createDocument method should throw a NAMESPACE_ERR if the qualifiedName has |
| a prefix that is xml and the namespaceURI is different from |
| http://www..w3.org/XML/1998/namespace. |
| Call the createDocument on this DOMImplementation with namespaceURI that is |
| http://www.w3.org/xml/1998/namespace and a qualifiedName that has the prefix xml |
| Check if the NAMESPACE_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.w3.org/xml/1998/namespace""/> |
| <var name="qualifiedName" type="DOMString" value=""xml:root""/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <assertDOMException id="domimplementationcreatedocument05"> |
| <NAMESPACE_ERR> |
| <createDocument obj="domImpl" var="newDoc" namespaceURI="namespaceURI" qualifiedName="qualifiedName" doctype="docType"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationcreatedocument07.xml.unknown |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="domimplementationcreatedocument07"> |
| <metadata> |
| <title>domimplementationcreatedocument07</title> |
| <creator>IBM</creator> |
| <description> |
| The createDocument method should raise a NAMESPACE_ERR if the qualifiedName is malformed |
| Invoke the createDocument method on this DOMImplementation object with null values |
| for namespaceURI and docType and a malformed qualifiedName. |
| The NAMESPACE_ERR should be raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.w3.org/DOMTest/level2""/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <assertDOMException id="domimplementationcreatedocument07"> |
| <NAMESPACE_ERR> |
| <createDocument obj="domImpl" var="newDoc" namespaceURI="namespaceURI" qualifiedName='":"' doctype="docType"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationcreatedocumenttype01.xml.unknown |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="domimplementationcreatedocumenttype01"> |
| <metadata> |
| <title>domimplementationcreatedocumenttype01</title> |
| <creator>IBM</creator> |
| <description> |
| The method createDocumentType with valid values for qualifiedName, publicId and |
| systemId should create an empty DocumentType node. |
| Invoke createDocument on this DOMImplementation with a valid qualifiedName and different |
| publicIds and systemIds. Check if the the DocumentType node was created with its |
| ownerDocument attribute set to null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocument"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDocType" type="DocumentType"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="qualifiedName" type="DOMString" value=""test:root""/> |
| <var name="publicId" type="DOMString"/> |
| <var name="systemId" type="DOMString"/> |
| <var name="publicIds" type="List"> |
| <member>"1234"</member> |
| <member>"test"</member> |
| </var> |
| <var name="systemIds" type="List"> |
| <member>""</member> |
| <member>"test"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <for-each collection="publicIds" member="publicId"> |
| <for-each collection="systemIds" member="systemId"> |
| <createDocumentType obj="domImpl" var="newDocType" qualifiedName="qualifiedName" publicId="publicId" systemId="systemId"/> |
| <assertNotNull actual="newDocType" id="domimplementationcreatedocumenttype01_newDocType"/> |
| <ownerDocument obj="newDocType" var="ownerDocument"/> |
| <assertNull actual="ownerDocument" id="domimplementationcreatedocumenttype01_ownerDocument"/> |
| </for-each> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationcreatedocumenttype02.xml.unknown |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="domimplementationcreatedocumenttype02"> |
| <metadata> |
| <title>domimplementationcreatedocumenttype02</title> |
| <creator>IBM</creator> |
| <description> |
| The method createDocumentType with valid values for qualifiedName, publicId and |
| systemId should create an empty DocumentType node. |
| Invoke createDocument on this DOMImplementation with a different valid qualifiedNames |
| and a valid publicId and systemId. Check if the the DocumentType node was created |
| with its ownerDocument attribute set to null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocType"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDocType" type="DocumentType"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="publicId" type="DOMString" value=""http://www.w3.org/DOM/Test/dom2.dtd""/> |
| <var name="systemId" type="DOMString" value=""dom2.dtd""/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="qualifiedNames" type="List"> |
| <member>"_:_"</member> |
| <member>"_:h0"</member> |
| <member>"_:test"</member> |
| <member>"_:_."</member> |
| <member>"_:a-"</member> |
| <member>"l_:_"</member> |
| <member>"ns:_0"</member> |
| <member>"ns:a0"</member> |
| <member>"ns0:test"</member> |
| <member>"ns:EEE."</member> |
| <member>"ns:_-"</member> |
| <member>"a.b:c"</member> |
| <member>"a-b:c.j"</member> |
| <member>"a-b:c"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <for-each collection="qualifiedNames" member="qualifiedName"> |
| <createDocumentType obj="domImpl" var="newDocType" qualifiedName="qualifiedName" publicId="publicId" systemId="systemId"/> |
| <assertNotNull actual="newDocType" id="domimplementationcreatedocumenttype02_newDocType"/> |
| <ownerDocument obj="newDocType" var="ownerDocument"/> |
| <assertNull actual="ownerDocument" id="domimplementationcreatedocumenttype02_ownerDocument"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationcreatedocumenttype04.xml.unknown |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="domimplementationcreatedocumenttype04"> |
| <metadata> |
| <title>domimplementationcreatedocumenttype04</title> |
| <creator>IBM</creator> |
| <description> |
| The method createDocumentType should raise a INVALID_CHARACTER_ERR if the qualifiedName |
| contains an illegal characters. |
| Invoke createDocument on this DOMImplementation with qualifiedNames having illegal characters. |
| Check if an INVALID_CHARACTER_ERR is raised in each case. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-DOM-createDocType"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDocType" type="DocumentType"/> |
| <var name="publicId" type="DOMString" value=""http://www.w3.org/DOM/Test/dom2.dtd""/> |
| <var name="systemId" type="DOMString" value=""dom2.dtd""/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="qualifiedNames" type="List"> |
| <member>"{"</member> |
| <member>"}"</member> |
| <member>"'"</member> |
| <member>"~"</member> |
| <member>"`"</member> |
| <member>"@"</member> |
| <member>"#"</member> |
| <member>"$"</member> |
| <member>"%"</member> |
| <member>"^"</member> |
| <member>"&"</member> |
| <member>"*"</member> |
| <member>"("</member> |
| <member>")"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <for-each collection="qualifiedNames" member="qualifiedName"> |
| <assertDOMException id="domimplementationcreatedocumenttype04"> |
| <INVALID_CHARACTER_ERR> |
| <createDocumentType obj="domImpl" var="newDocType" qualifiedName="qualifiedName" publicId="publicId" systemId="systemId"/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationfeaturecore.xml.unknown |
|---|
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationfeaturexmlversion2.xml.unknown |
|---|
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationhasfeature01.xml.unknown |
|---|
| 0,0 → 1,70 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="domimplementationhasfeature01"> |
| <metadata> |
| <title>domimplementationhasfeature01</title> |
| <creator>IBM</creator> |
| <description> |
| The method "hasFeature(feature,version)" tests if the DOMImplementation implements |
| a specific feature and if so returns true. |
| Call the hasFeature method on this DOMImplementation with a combination of features |
| versions as below. Valid feature names are case insensitive and versions "2.0", |
| "1.0" and if the version is not specified, supporting any version of the feature |
| should return true. Check if the value returned value was true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="version" type="DOMString" value=""""/> |
| <var name="version1" type="DOMString" value=""1.0""/> |
| <var name="version2" type="DOMString" value=""2.0""/> |
| <var name="featureCore" type="DOMString"/> |
| <var name="featureXML" type="DOMString"/> |
| <var name="success" type="boolean"/> |
| <var name="featuresXML" type="List"> |
| <member>"XML"</member> |
| <member>"xmL"</member> |
| </var> |
| <var name="featuresCore" type="List"> |
| <member>"Core"</member> |
| <member>"CORE"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <for-each collection="featuresXML" member="featureXML"> |
| <hasFeature obj="domImpl" var="success" feature="featureXML" version="version"/> |
| <assertTrue actual="success" id="domimplementationhasfeature01_XML_1"/> |
| <hasFeature obj="domImpl" var="success" feature="featureXML" version="version1"/> |
| <assertTrue actual="success" id="domimplementationhasfeature01_XML_2"/> |
| </for-each> |
| <for-each collection="featuresCore" member="featureCore"> |
| <hasFeature obj="domImpl" var="success" feature="featureCore" version="version"/> |
| <assertTrue actual="success" id="domimplementationhasfeature01_Core_1"/> |
| <!-- result is indeterminant since Core was not defined in DOM L1 --> |
| <hasFeature obj="domImpl" var="success" feature="featureCore" version="version1"/> |
| <hasFeature obj="domImpl" var="success" feature="featureCore" version="version2"/> |
| <assertTrue actual="success" id="domimplementationhasfeature01_Core_3"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/domimplementationhasfeature02.xml.unknown |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="domimplementationhasfeature02"> |
| <metadata> |
| <title>domimplementationhasfeature02</title> |
| <creator>IBM</creator> |
| <description> |
| The method "hasFeature(feature,version)" tests if the DOMImplementation implements |
| a specific feature and if not returns false. |
| Call the hasFeature method on this DOMImplementation with a unfimiliar values for |
| feature and version. Check if the value returned was false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="success" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <hasFeature obj="domImpl" var="success" feature=""Blah Blah"" version=""""/> |
| <assertFalse actual="success" id="domimplementationhasfeature02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementgetattributenodens01.xml.unknown |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementgetattributenodens01"> |
| <metadata> |
| <title>elementgetattributenodens01</title> |
| <creator>IBM</creator> |
| <description> |
| The method getAttributeNodeNS retrieves an Attr node by local name and namespace URI. |
| Create a new element node and add 2 new attribute nodes to it that have the same |
| local name but different namespaceURIs and prefixes. |
| Retrieve an attribute using namespace and localname and check its value, name and |
| namespaceURI. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAtNodeNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute1" type="Attr"/> |
| <var name="attribute2" type="Attr"/> |
| <var name="newAttribute1" type="Attr"/> |
| <var name="newAttribute2" type="Attr"/> |
| <var name="attribute" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="attNodeName" type="DOMString"/> |
| <var name="attrLocalName" type="DOMString"/> |
| <var name="attrNS" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"namespaceURI"' |
| qualifiedName='"root"'/> |
| <createAttributeNS var="attribute1" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Level2"' qualifiedName='"l2:att"'/> |
| <setAttributeNodeNS var="newAttribute1" obj="element" newAttr="attribute1"/> |
| <createAttributeNS var="attribute2" obj="doc" namespaceURI='"http://www.w3.org/DOM/Level1"' |
| qualifiedName='"att"'/> |
| <setAttributeNodeNS var="newAttribute2" obj="element" newAttr="attribute2"/> |
| <getAttributeNodeNS var="attribute" obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Level2"' localName='"att"'/> |
| <nodeValue var="attrValue" obj="attribute"/> |
| <name var="attrName" obj="attribute" interface="Attr"/> |
| <nodeName var="attNodeName" obj="attribute"/> |
| <localName var="attrLocalName" obj="attribute"/> |
| <namespaceURI var="attrNS" obj="attribute"/> |
| <assertEquals actual="attrValue" expected='""' id="elementgetattributenodens01_attrValue" ignoreCase="false"/> |
| <assertEquals actual="attrName" expected='"l2:att"' id="elementgetattributenodens01_attrName" ignoreCase="false"/> |
| <assertEquals actual="attNodeName" expected='"l2:att"' id="elementgetattributenodens01_attrNodeName" ignoreCase="false"/> |
| <assertEquals actual="attrLocalName" expected='"att"' id="elementgetattributenodens01_attrLocalName" ignoreCase="false"/> |
| <assertEquals actual="attrNS" expected='"http://www.w3.org/DOM/Level2"' id="elementgetattributenodens01_attrNs" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementgetattributenodens02.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementgetattributenodens02"> |
| <metadata> |
| <title>elementgetattributenodens02</title> |
| <creator>IBM</creator> |
| <description> |
| The method getAttributeNodeNS retrieves an Attr node by local name and namespace URI. |
| Create a new element node and add a new attribute node to it. Using the getAttributeNodeNS, |
| retrieve the newly added attribute node and check its value. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAtNodeNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute1" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"namespaceURI"' |
| qualifiedName='"root"'/> |
| <createAttributeNS var="attribute" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Level2"' qualifiedName='"l2:att"'/> |
| <setAttributeNodeNS var="newAttribute1" obj="element" newAttr="attribute"/> |
| <getAttributeNodeNS var="attribute" obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Level2"' localName='"att"'/> |
| <nodeValue var="attrValue" obj="attribute"/> |
| <assertEquals actual="attrValue" expected='""' id="elementgetattributenodens02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementgetattributenodens03.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementgetattributenodens03"> |
| <metadata> |
| <title>elementgetattributenodens03</title> |
| <creator>IBM</creator> |
| <description> |
| The method getAttributeNodeNS retrieves an Attr node by local name and namespace URI. |
| Using the getAttributeNodeNS, retrieve and verify the value of the default |
| attribute node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAtNodeNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="childList" type="NodeList"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS var="childList" obj="doc" localName='"employee"' |
| namespaceURI='"http://www.nist.gov"' interface="Document"/> |
| <item var="element" obj="childList" index="1" interface="NodeList"/> |
| <getAttributeNodeNS var="attribute" obj="element" localName='"defaultAttr"' |
| namespaceURI="nullNS"/> |
| <nodeValue var="attrValue" obj="attribute"/> |
| <assertEquals actual="attrValue" expected='"defaultVal"' id="elementgetattributenodens03" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementgetattributens02.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementgetattributens02"> |
| <metadata> |
| <title>elementgetattributens02</title> |
| <creator>IBM</creator> |
| <description> |
| The method getAttributeNS retrieves an attribute value by local name and namespace URI. |
| Using the getAttributeNodeNS, retreive and verify the value of the default |
| attribute node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAttrNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="childList" type="NodeList"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS var="childList" obj="doc" localName='"employee"' |
| namespaceURI='"http://www.nist.gov"' interface="Document"/> |
| <item var="element" obj="childList" index="1" interface="NodeList"/> |
| <getAttributeNS var="attrValue" obj="element" localName='"defaultAttr"' namespaceURI="nullNS"/> |
| <assertEquals actual="attrValue" expected='"defaultVal"' id="elementgetattributens02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementgetelementsbytagnamens02.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementgetelementsbytagnamens02"> |
| <metadata> |
| <title>elementgetelementsbytagnamens02</title> |
| <creator>IBM</creator> |
| <description> |
| The method getElementsByTagNameNS returns a NodeList of all the Elements with a given local |
| name and namespace URI in the order in which they are encountered in a preorder traversal |
| of the Document tree. |
| Invoke getElementsByTagNameNS on the documentElement with values for namespaceURI '*' and |
| localName '*'. Verify if this returns a nodeList of 0 elements. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <documentElement var="element" obj="doc"/> |
| <getElementsByTagNameNS var="elementList" obj="element" |
| namespaceURI='"**"' localName='"*"' interface="Element" /> |
| <assertSize size="0" collection="elementList" id="elementgetelementsbytagnamens02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementgetelementsbytagnamens04.xml.unknown |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementgetelementsbytagnamens04"> |
| <metadata> |
| <title>elementgetelementsbytagnamens04</title> |
| <creator>IBM</creator> |
| <description> |
| Returns a NodeList of all the Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of the Document tree. |
| Create a new element node ('root') and append three newly created child nodes (all have |
| local name 'child' and defined in different namespaces). |
| Test 1: invoke getElementsByTagNameNS to retrieve one of the children. |
| Test 2: invoke getElementsByTagNameNS with the value of namespace equals to '*', and |
| verify that the node list has length of 3. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="child1" type="Element"/> |
| <var name="child2" type="Element"/> |
| <var name="child3" type="Element"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM"' |
| qualifiedName='"root"'/> |
| <createElementNS var="child1" obj="doc" namespaceURI='"http://www.w3.org/DOM/Level1"' |
| qualifiedName='"dom:child"'/> |
| <createElementNS var="child2" obj="doc" namespaceURI="nullNS" |
| qualifiedName='"child"'/> |
| <createElementNS var="child3" obj="doc" namespaceURI='"http://www.w3.org/DOM/Level2"' |
| qualifiedName='"dom:child"'/> |
| <appendChild var="appendedChild" obj="element" newChild="child1"/> |
| <appendChild var="appendedChild" obj="element" newChild="child2"/> |
| <appendChild var="appendedChild" obj="element" newChild="child3"/> |
| <getElementsByTagNameNS var="elementList" obj="element" namespaceURI="nullNS" |
| localName='"child"' interface="Element" /> |
| <assertSize size="1" collection="elementList" id="elementgetelementsbytagnamens04_1"/> |
| <getElementsByTagNameNS var="elementList" obj="element" namespaceURI='"*"' |
| localName='"child"' interface="Element" /> |
| <assertSize size="3" collection="elementList" id="elementgetelementsbytagnamens04_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementgetelementsbytagnamens05.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementgetelementsbytagnamens05"> |
| <metadata> |
| <title>elementgetelementsbytagnamens05</title> |
| <creator>IBM</creator> |
| <description> |
| Returns a NodeList of all the Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of the Document tree. |
| Invoke getElementsByTagNameNS on the documentElement with the following values: |
| namespaceURI: 'http://www.altavista.com' |
| localName: '*'. |
| Verify if this returns a nodeList of 1 elements. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <documentElement var="element" obj="doc"/> |
| <getElementsByTagNameNS var="elementList" obj="element" |
| namespaceURI='"http://www.altavista.com"' localName='"*"' interface="Element" /> |
| <assertSize size="1" collection="elementList" id="elementgetelementsbytagnamens05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementhasattribute01.xml.unknown |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementhasattribute01"> |
| <metadata> |
| <title>elementhasattribute01</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttribute returns true when an attribute with a given name is specified |
| on this element or has a default value, false otherwise |
| Invoke the hasAttribute method to check if the documentElement has attributres. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeHasAttrs"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement var="element" obj="doc"/> |
| <hasAttribute var="state" obj="element" name='""'/> |
| <assertFalse actual="state" id="elementhasattribute01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementhasattribute02.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementhasattribute02"> |
| <metadata> |
| <title>elementhasattribute02</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttribute returns true when an attribute with a given name is specified |
| on this element or has a default value, false otherwise |
| Invoke the hasAttribute method to on an element with default attributes and verify if it |
| returns true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeHasAttrs"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"emp:employee"' |
| var="elementList"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <assertNotNull actual="element" id="empEmployeeNotNull"/> |
| <hasAttribute var="state" obj="element" name='"defaultAttr"'/> |
| <assertTrue actual="state" id="elementhasattribute02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementhasattribute03.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementhasattribute03"> |
| <metadata> |
| <title>elementhasattribute03</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttribute returns true when an attribute with a given name is specified |
| on this element or has a default value, false otherwise. |
| Create an element Node and an attribute Node. Invoke hasAttribute method |
| to verify that there is no attribute. Append the attribute node to the element node. |
| Invoke the hasAttribute method on the element and verify if it returns true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeHasAttrs"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createElement var="element" obj="doc" tagName='"address"'/> |
| <createAttribute var="attribute" obj="doc" name='"domestic"'/> |
| <hasAttribute var="state" obj="element" name='"domestic"'/> |
| <assertFalse actual="state" id="elementhasattribute03_False"/> |
| <setAttributeNode var="newAttribute" obj="element" newAttr="attribute"/> |
| <hasAttribute var="state" obj="element" name='"domestic"'/> |
| <assertTrue actual="state" id="elementhasattribute03_True"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementhasattribute04.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementhasattribute04"> |
| <metadata> |
| <title>elementhasattribute04</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttribute returns true when an attribute with a given name is specified |
| on this element or has a default value, false otherwise. |
| Create an element Node and an attribute Node and add the attribute node to the element. |
| Invoke the hasAttribute method on the element and verify if the method returns true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeHasAttrs"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createElement var="element" obj="doc" tagName='"address"'/> |
| <createAttribute var="attribute" obj="doc" name='"domestic"'/> |
| <setAttributeNode var="newAttribute" obj="element" newAttr="attribute"/> |
| <hasAttribute var="state" obj="element" name='"domestic"'/> |
| <assertTrue actual="state" id="elementhasattribute04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementhasattributens01.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementhasattributens01"> |
| <metadata> |
| <title>elementhasattributens01</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttributeNS returns true when an attribute with a given local name |
| and namespace |
| URI is specified on this element or has a default value, false otherwise. |
| Retreive the first employee element node. Invoke the hasAttributeNS method to check if it |
| has the xmlns attribute that belongs to the namespace http://www.w3.org/2000/xmlns/. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"employee"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <hasAttributeNS var="state" obj="element" |
| namespaceURI='"http://www.w3.org/2000/xmlns/"' localName='"xmlns"'/> |
| <assertTrue actual="state" id="elementhasattributens01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementhasattributens02.xml.unknown |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementhasattributens02"> |
| <metadata> |
| <title>elementhasattributens02</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttributeNS returns true when an attribute with a given local |
| name and namespace URI is specified on this element or has a default value, |
| false otherwise. |
| Create a new element and attribute node that belong to the same namespace. |
| Add the attribute node to the element node. Check if the newly created element |
| node has an attribute by invoking the hasAttributeNS method with appropriate |
| values for the namespaceURI and localName parameters. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createElementNS var="element" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM"' qualifiedName='"address"'/> |
| <createAttributeNS var="attribute" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM"' qualifiedName='"domestic"'/> |
| <setAttributeNode var="newAttribute" obj="element" newAttr="attribute"/> |
| <hasAttributeNS var="state" obj="element" |
| namespaceURI='"http://www.w3.org/DOM"' localName='"domestic"'/> |
| <assertTrue actual="state" id="hasDomesticAttr"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementhasattributens03.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementhasattributens03"> |
| <metadata> |
| <title>elementhasattributens03</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttributeNS returns true when an attribute with a given local name |
| and namespace URI is specified on this element or has a default value, |
| false otherwise. |
| Create a new element and an attribute node that has an empty namespace. |
| Add the attribute node to the element node. Check if the newly created element |
| node has an attribute by invoking the hasAttributeNS method with appropriate |
| values for the namespaceURI and localName parameters. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttrNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM"' |
| qualifiedName='"address"'/> |
| <assertNotNull actual="element" id="createElementNotNull"/> |
| <createAttributeNS var="attribute" obj="doc" namespaceURI='nullNS' qualifiedName='"domestic"'/> |
| <setAttributeNode var="newAttribute" obj="element" newAttr="attribute"/> |
| <hasAttributeNS var="state" obj="element" namespaceURI="nullNS" localName='"domestic"'/> |
| <assertTrue actual="state" id="elementhasattributens03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementremoveattributens01.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementremoveattributens01"> |
| <metadata> |
| <title>elementremoveattributens01</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeAttributeNS removes an attribute by local name and namespace URI. |
| Create a new element and add a new attribute node to it. |
| Remove the attribute node using the removeAttributeNodeNS method. |
| Check if the attribute was remove by invoking the hasAttributeNS |
| method on the element and check if it returns false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElRemAtNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM"' |
| qualifiedName='"elem"'/> |
| <createAttributeNS var="attribute" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Test/createAttributeNS"' qualifiedName='"attr"'/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="attribute"/> |
| <removeAttributeNS obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/createAttributeNS"' localName='"attr"'/> |
| <hasAttributeNS var="state" obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/createAttributeNS"' localName='"attr"'/> |
| <assertFalse actual="state" id="elementremoveattributens01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributenodens01.xml.unknown |
|---|
| 0,0 → 1,78 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributenodens01"> |
| <metadata> |
| <title>elementsetattributenodens01</title> |
| <creator>IBM</creator> |
| <description> |
| Testing Element.setAttributeNodeNS: If an attribute with that local name |
| and that namespace URI is already present in the element, it is replaced |
| by the new one. |
| Create a new element and two new attribute nodes (in the same namespace |
| and same localNames). |
| Add the two new attribute nodes to the element node using the |
| setAttributeNodeNS method. Check that only one attribute is added, check |
| the value of this attribute. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute1" type="Attr"/> |
| <var name="attribute2" type="Attr"/> |
| <var name="attrNode" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="attrNS" type="DOMString"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Test/Level2"' |
| qualifiedName='"new:element"'/> |
| <createAttributeNS var="attribute1" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Test/att1"' |
| qualifiedName='"p1:att"'/> |
| <createAttributeNS var="attribute2" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Test/att1"' |
| qualifiedName='"p2:att"'/> |
| <value obj="attribute2" value='"value2"' interface="Attr"/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="attribute1"/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="attribute2"/> |
| <getAttributeNodeNS var="attrNode" obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/att1"' |
| localName='"att"'/> |
| <nodeName var="attrName" obj="attrNode"/> |
| <namespaceURI var="attrNS" obj="attrNode"/> |
| <assertEquals actual="attrName" expected='"p2:att"' id="elementsetattributenodens01_attrName" ignoreCase="false"/> |
| <assertEquals actual="attrNS" expected='"http://www.w3.org/DOM/Test/att1"' |
| id="elementsetattributenodens01_attrNS" ignoreCase="false"/> |
| <attributes var="attributes" obj="element"/> |
| <length var="length" obj="attributes" interface="NamedNodeMap"/> |
| <assertEquals actual="length" expected="1" id="length" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributenodens02.xml.unknown |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributenodens02"> |
| <metadata> |
| <title>elementsetattributenodens02</title> |
| <creator>IBM</creator> |
| <description> |
| Test the setAttributeNodeNS method. |
| Retreive the street attribute from the second address element node. |
| Clone it and add it to the first address node. The INUSE_ATTRIBUTE_ERR exception |
| should not be thrown. Check the name and value of the newly added node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="element2" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="attributeCloned" type="Attr"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" |
| namespaceURI='"http://www.nist.gov"' |
| localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <getAttributeNodeNS var="attribute" obj="element" |
| namespaceURI="nullNS" localName='"street"'/> |
| <cloneNode var="attributeCloned" obj="attribute" deep="true"/> |
| <item var="element2" obj="elementList" index="2" interface="NodeList"/> |
| <setAttributeNodeNS var="newAttr" obj="element2" newAttr="attributeCloned"/> |
| <nodeName var="attrName" obj="newAttr"/> |
| <nodeValue var="attrValue" obj="newAttr"/> |
| <assertEquals actual="attrName" expected='"street"' id="elementsetattributenodens02_attrName" ignoreCase="false"/> |
| <assertEquals actual="attrValue" expected='"Yes"' id="elementsetattributenodens02_attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributenodens03.xml.unknown |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributenodens03"> |
| <metadata> |
| <title>elementsetattributenodens03</title> |
| <creator>IBM</creator> |
| <description> |
| The method setAttributeNodeNS adds a new attribute and raises the |
| INUSE_ATTRIBUTE_ERR exception if the newAttr is already an attribute of |
| another Element object. |
| Retreive an attribute node of an existing element node. Attempt to add it to an another |
| element node. Check if the INUSE_ATTRIBUTE_ERR exception is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element1" type="Element"/> |
| <var name="element2" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" |
| namespaceURI='"http://www.nist.gov"' |
| localName='"address"' interface="Document"/> |
| <item var="element1" obj="elementList" index="1" interface="NodeList"/> |
| <getAttributeNodeNS var="attribute" obj="element1" |
| namespaceURI="nullNS" localName='"street"'/> |
| <item var="element2" obj="elementList" index="2" interface="NodeList"/> |
| <assertDOMException id="elementsetattributenodens03"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setAttributeNodeNS var="newAttribute" obj="element2" newAttr="attribute"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributenodens04.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributenodens04"> |
| <metadata> |
| <title>elementsetattributenodens04</title> |
| <creator>IBM</creator> |
| <description> |
| The method setAttributeNodeNS Adds a new attribute and raises an INUSE_ATTRIBUTE_ERR |
| if newAttr is already an attribute of another Element object. |
| Create two new element nodes and a new attribute node. Attempt to add the same attribute |
| node to the same two element nodes. |
| Check if an INUSE_ATTRIBUTE_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element1" type="Element"/> |
| <var name="element2" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element1" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"elem1"'/> |
| <createElementNS var="element2" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"elem2"'/> |
| <createAttributeNS var="attribute" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"attr"'/> |
| <setAttributeNodeNS var="newAttribute" obj="element1" newAttr="attribute"/> |
| <assertDOMException id="elementsetattributenodens04"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setAttributeNodeNS var="newAttribute" obj="element2" newAttr="attribute"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributenodens05.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributenodens05"> |
| <metadata> |
| <title>elementsetattributenodens05</title> |
| <creator>IBM</creator> |
| <description> |
| The method setAttributeNodeNS Adds a new attribute and raises |
| an WRONG_DOCUMENT_ERR if newAttr was created from a different document |
| than the one that created the element. |
| Create new element and attribute nodes in different documents. |
| Attempt to add the attribute node to the element node. |
| Check if an WRONG_DOCUMENT_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docAlt" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="docAlt" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Test"' |
| qualifiedName='"elem1"'/> |
| <createAttributeNS var="attribute" obj="docAlt" |
| namespaceURI='"http://www.w3.org/DOM/Test"' |
| qualifiedName='"attr"'/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="attribute"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributenodens06.xml.unknown |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributenodens06"> |
| <metadata> |
| <title>elementsetattributenodens06</title> |
| <creator>IBM</creator> |
| <description> |
| The method setAttributeNodeNS Adds a new attribute and raises an WRONG_DOCUMENT_ERR if this node |
| is readonly. |
| Attempt to add an attribute node to an element node which is part of the replacement text of |
| a read-only EntityReference node. |
| Check if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="attribute2" type="Attr"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newAttribute" type="Node"/> |
| <var name="newChild" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"elem1"'/> |
| <createAttributeNS var="attribute" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"attr"'/> |
| <createEntityReference var="entRef" obj="doc" name='"ent4"'/> |
| <appendChild var="newChild" obj="attribute" newChild="entRef"/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="attribute"/> |
| <childNodes var="elementList" obj="entRef"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <createAttributeNS var="attribute2" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"attr2"'/> |
| <assertDOMException id="elementsetattributenodens06"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="attribute2"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributens01.xml.unknown |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributens01"> |
| <metadata> |
| <title>elementsetattributens01</title> |
| <creator>IBM</creator> |
| <description> |
| The method setAttributeNS adds a new attribute. |
| Create a new element and add a new attribute node to it using the setAttributeNS method. |
| Check if the attribute was correctly set by invoking the getAttributeNodeNS method |
| and checking the nodeName and nodeValue of the returned nodes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM"' qualifiedName='"dom:elem"'/> |
| <setAttributeNS obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/setAttributeNS"' |
| qualifiedName ='"attr"' value='"value"'/> |
| <getAttributeNodeNS var="attribute" obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/setAttributeNS"' |
| localName='"attr"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <nodeValue var="attrValue" obj="attribute"/> |
| <assertEquals actual="attrName" expected='"attr"' id="elementsetattributens01_attrName" ignoreCase="false"/> |
| <assertEquals actual="attrValue" expected='"value"' id="elementsetattributens01_attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributens02.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributens02"> |
| <metadata> |
| <title>elementsetattributens02</title> |
| <creator>IBM</creator> |
| <description> |
| The method setAttributeNS adds a new attribute. |
| Retrieve an existing element node with attributes and add a new attribute node to it using |
| the setAttributeNS method. Check if the attribute was correctly set by invoking the |
| getAttributeNodeNS method and checking the nodeName and nodeValue of the returned nodes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" |
| namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <setAttributeNS obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/setAttributeNS"' |
| qualifiedName ='"this:street"' value='"Silver Street"'/> |
| <getAttributeNodeNS var="attribute" obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/setAttributeNS"' localName='"street"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <nodeValue var="attrValue" obj="attribute"/> |
| <assertEquals actual="attrName" expected='"this:street"' id="elementsetattributens02_attrName" ignoreCase="false"/> |
| <assertEquals actual="attrValue" expected='"Silver Street"' id="elementsetattributens02_attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributens03.xml.unknown |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributens03"> |
| <metadata> |
| <title>elementsetattributens03</title> |
| <creator>IBM</creator> |
| <description> |
| The method setAttributeNS adds a new attribute. |
| Retreive an existing element node with a default attribute node and |
| add two new attribute nodes that have the same local name as the |
| default attribute but different namespaceURI to it using the setAttributeNS method. |
| Check if the attribute was correctly set by invoking the getAttributeNodeNS method |
| and checking the nodeName and nodeValue of the returned nodes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName var="elementList" obj="doc" tagname='"emp:employee"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <assertNotNull actual="element" id="empEmployeeNotNull"/> |
| <setAttributeNS obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/1"' |
| qualifiedName ='"defaultAttr"' value='"default1"'/> |
| <setAttributeNS obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/2"' |
| qualifiedName ='"defaultAttr"' value='"default2"'/> |
| <getAttributeNodeNS var="attribute" obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/1"' localName='"defaultAttr"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <nodeValue var="attrValue" obj="attribute"/> |
| <assertEquals actual="attrName" expected='"defaultAttr"' id="elementsetattributens03_attrName" ignoreCase="false"/> |
| <assertEquals actual="attrValue" expected='"default1"' id="elementsetattributens03_attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributens04.xml.unknown |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributens04"> |
| <metadata> |
| <title>elementsetattributens04</title> |
| <creator>IBM</creator> |
| <description> |
| The method setAttributeNS adds a new attribute and raises a INVALID_CHARACTER_ERR if |
| the specified qualified name contains an illegal character. |
| Invoke the setAttributeNS method on this Element object with a valid value for |
| namespaceURI, and qualifiedNames that contain illegal characters. Check if the an |
| INVALID_CHARACTER_ERR was thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="qualifiedNames" type="List"> |
| <member>"/"</member> |
| <member>"//"</member> |
| <member>"\\"</member> |
| <member>";"</member> |
| <member>"&"</member> |
| <member>"*"</member> |
| <member>"]]"</member> |
| <member>">"</member> |
| <member>"<"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Test/L2"' |
| qualifiedName='"dom:elem"'/> |
| <for-each collection="qualifiedNames" member="qualifiedName"> |
| <assertDOMException id="elementsetattributens04"> |
| <INVALID_CHARACTER_ERR> |
| <setAttributeNS obj="element" |
| namespaceURI='"http://www.w3.org/DOM/Test/L2"' |
| qualifiedName ="qualifiedName" value='"test"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributens05.xml.unknown |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributens05"> |
| <metadata> |
| <title>elementsetattributens05</title> |
| <creator>IBM</creator> |
| <description> |
| The method setAttributeNS adds a new attribute and raises a NAMESPACE_ERR if the |
| qualifiedName has a prefix and the namespaceURI is null. |
| Invoke the setAttributeNS method on a new Element object with null namespaceURI and a |
| qualifiedName that has a namespace prefix. Check if the NAMESPACE_ERR was thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" |
| namespaceURI='"http://www.w3.org/DOM/Test/L2"' |
| qualifiedName='"dom:elem"'/> |
| <assertDOMException id="elementsetattributens05"> |
| <NAMESPACE_ERR> |
| <setAttributeNS obj="element" namespaceURI="nullNS" |
| qualifiedName='"dom:root"' value='"test"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributens08.xml.unknown |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="elementsetattributens08"> |
| <metadata> |
| <title>elementsetattributens08</title> |
| <creator>IBM</creator> |
| <description> |
| The method setAttributeNS adds a new attribute and raises a NAMESPACE_ERR |
| if the qualifiedName, or its prefix, is "xmlns" and the namespaceURI is |
| different from "http://www.w3.org/2000/xmlns/". |
| Invoke the setAttributeNS method on a new Element object with namespaceURI that is |
| http://www.w3.org/DOMTest/level2 and a qualifiedName that has the prefix xmlns and once |
| again with a qualifiedName that is xmlns. |
| Check if the NAMESPACE_ERR was thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" |
| namespaceURI='"http://www.w3.org/DOMTest/level2"' |
| qualifiedName='"dom:elem"'/> |
| <assertDOMException id="elementsetattributens08_Err1"> |
| <NAMESPACE_ERR> |
| <setAttributeNS obj="element" |
| namespaceURI='"http://www.w3.org/DOMTest/level2"' |
| qualifiedName='"xmlns"' value='"test"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| <assertDOMException id="elementsetattributens08_Err2"> |
| <NAMESPACE_ERR> |
| <setAttributeNS obj="element" |
| namespaceURI='"http://www.w3.org/DOMTest/level2"' |
| qualifiedName='"xmlns:root"' value='"test"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/elementsetattributensurinull.xml.unknown |
|---|
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/.cvsignore |
|---|
| --- test/testcases/tests/level2/core/files/CVS/Entries (nonexistent) |
| +++ test/testcases/tests/level2/core/files/CVS/Entries (revision 4364) |
| @@ -0,0 +1,21 @@ |
| +/.cvsignore/1.2/Fri Apr 3 02:47:56 2009// |
| +/hc_staff.html/1.6/Fri Apr 3 02:47:56 2009// |
| +/hc_staff.svg/1.4/Fri Apr 3 02:47:56 2009// |
| +/hc_staff.xhtml/1.6/Fri Apr 3 02:47:56 2009// |
| +/hc_staff.xml/1.6/Fri Apr 3 02:47:56 2009// |
| +/internalSubset01.js/1.1/Fri Apr 3 02:47:56 2009/-kb/ |
| +/nodtdstaff.svg/1.2/Fri Apr 3 02:47:56 2009// |
| +/nodtdstaff.xml/1.1/Fri Apr 3 02:47:56 2009// |
| +/staff.dtd/1.1/Fri Apr 3 02:47:56 2009// |
| +/staff.svg/1.2/Fri Apr 3 02:47:56 2009// |
| +/staff.xml/1.1/Fri Apr 3 02:47:56 2009// |
| +/staff2.dtd/1.2/Fri Apr 3 02:47:56 2009// |
| +/staff2.svg/1.1/Fri Apr 3 02:47:56 2009/-kb/ |
| +/staff2.xml/1.1/Fri Apr 3 02:47:56 2009// |
| +/staffNS.dtd/1.1/Fri Apr 3 02:47:56 2009// |
| +/staffNS.svg/1.3/Fri Apr 3 02:47:56 2009// |
| +/staffNS.xml/1.2/Fri Apr 3 02:47:56 2009// |
| +/svgtest.js/1.2/Fri Apr 3 02:47:56 2009/-kb/ |
| +/svgunit.js/1.2/Fri Apr 3 02:47:56 2009/-kb/ |
| +/xhtml1-strict.dtd/1.5/Fri Apr 3 02:47:56 2009/-kb/ |
| +D |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level2/core/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/CVS/Template |
|---|
| --- test/testcases/tests/level2/core/files/hc_staff.html (nonexistent) |
| +++ test/testcases/tests/level2/core/files/hc_staff.html (revision 4364) |
| @@ -0,0 +1,48 @@ |
| +<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" |
| + "http://www.w3.org/TR/html4/strict.dtd" > |
| +<!-- This is comment number 1.--> |
| +<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>hc_staff</title><script type="text/javascript" src="svgunit.js"></script><script charset="UTF-8" type="text/javascript" src="svgtest.js"></script><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| + <p> |
| + <em>EMP0001</em> |
| + <strong>Margaret Martin</strong> |
| + <code>Accountant</code> |
| + <sup>56,000</sup> |
| + <var>Female</var> |
| + <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| + </p> |
| + <p> |
| + <em>EMP0002</em> |
| + <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| +This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| + <code>Secretary</code> |
| + <sup>35,000</sup> |
| + <var>Female</var> |
| + <acronym title="Yes" class="Yes">β Dallas, γ |
| + 98554</acronym> |
| + </p> |
| + <p> |
| + <em>EMP0003</em> |
| + <strong>Roger |
| + Jones</strong> |
| + <code>Department Manager</code> |
| + <sup>100,000</sup> |
| + <var>δ</var> |
| + <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| + </p> |
| + <p> |
| + <em>EMP0004</em> |
| + <strong>Jeny Oconnor</strong> |
| + <code>Personnel Director</code> |
| + <sup>95,000</sup> |
| + <var>Female</var> |
| + <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| + </p> |
| + <p> |
| + <em>EMP0005</em> |
| + <strong>Robert Myers</strong> |
| + <code>Computer Specialist</code> |
| + <sup>90,000</sup> |
| + <var>male</var> |
| + <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| + </p> |
| +</body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/hc_staff.svg |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST acronym dir CDATA "ltr"> |
| <!ATTLIST head xmlns CDATA #IMPLIED> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| <!ELEMENT svg (rect, script, head, body)> |
| <!ATTLIST svg xmlns CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #IMPLIED |
| y CDATA #IMPLIED |
| width CDATA #IMPLIED |
| height CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <!-- This is comment number 1.--> |
| <svg xmlns='http://www.w3.org/2000/svg'><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script><head xmlns='http://www.w3.org/1999/xhtml'><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title></head><body xmlns='http://www.w3.org/1999/xhtml'> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p> |
| <em>EMP0002</em> |
| <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>δ</var> |
| <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/hc_staff.xhtml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST acronym dir CDATA "ltr"> |
| ]> |
| <!-- This is comment number 1.--> |
| <html xmlns='http://www.w3.org/1999/xhtml'><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title><script type="text/javascript" src="svgunit.js"/><script charset="UTF-8" type="text/javascript" src="svgtest.js"/><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p> |
| <em>EMP0002</em> |
| <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>δ</var> |
| <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/hc_staff.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST acronym dir CDATA "ltr"> |
| ]> |
| <!-- This is comment number 1.--> |
| <html xmlns='http://www.w3.org/1999/xhtml'><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title><script type="text/javascript" src="svgunit.js"/><script charset="UTF-8" type="text/javascript" src="svgtest.js"/><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p> |
| <em>EMP0002</em> |
| <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>δ</var> |
| <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/internalSubset01.js |
|---|
| --- test/testcases/tests/level2/core/files/nodtdstaff.svg (nonexistent) |
| +++ test/testcases/tests/level2/core/files/nodtdstaff.svg (revision 4364) |
| @@ -0,0 +1,11 @@ |
| +<?xml version="1.0"?> |
| +<svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100"/> |
| + <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| + <employeeId>EMP0001</employeeId> |
| + <name>Margaret Martin</name> |
| + <position>Accountant</position> |
| + <salary>56,000</salary> |
| + <gender>Female</gender> |
| + <address domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| + </employee> |
| +</svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/nodtdstaff.xml |
|---|
| 0,0 → 1,11 |
| <?xml version="1.0"?> |
| <staff> |
| <employee> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| </staff> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/staff.dtd |
|---|
| 0,0 → 1,17 |
| <!ELEMENT employeeId (#PCDATA)> |
| <!ELEMENT name (#PCDATA)> |
| <!ELEMENT position (#PCDATA)> |
| <!ELEMENT salary (#PCDATA)> |
| <!ELEMENT address (#PCDATA)> |
| <!ELEMENT entElement ( #PCDATA ) > |
| <!ELEMENT gender ( #PCDATA | entElement )* > |
| <!ELEMENT employee (employeeId, name, position, salary, gender, address) > |
| <!ELEMENT staff (employee)+> |
| <!ATTLIST entElement |
| attr1 CDATA "Attr"> |
| <!ATTLIST address |
| domestic CDATA #IMPLIED |
| street CDATA "Yes"> |
| <!ATTLIST entElement |
| domestic CDATA "MALE" > |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/staff.svg |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg SYSTEM "staff.dtd" [ |
| <!ENTITY ent1 "es"> |
| <!ENTITY ent2 "1900 Dallas Road"> |
| <!ENTITY ent3 "Texas"> |
| <!ENTITY ent4 "<entElement domestic='Yes'>Element data</entElement><?PItarget PIdata?>"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ENTITY ent1 "This entity should be discarded"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST employee xmlns CDATA #IMPLIED> |
| <!ELEMENT svg (rect, script, employee+)> |
| <!ATTLIST svg |
| xmlns CDATA #FIXED "http://www.w3.org/2000/svg" |
| name CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <!-- This is comment number 1.--> |
| <svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds<![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Yes">&ent2; Dallas, &ent3; |
| 98554</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>&ent4;</gender> |
| <address domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0004</employeeId> |
| <name>Jeny Oconnor</name> |
| <position>Personnel Director</position> |
| <salary>95,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Y&ent1;">27 South Road. Dallas, Texas 98556</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/staff.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE staff SYSTEM "staff.dtd" [ |
| <!ENTITY ent1 "es"> |
| <!ENTITY ent2 "1900 Dallas Road"> |
| <!ENTITY ent3 "Texas"> |
| <!ENTITY ent4 "<entElement domestic='Yes'>Element data</entElement><?PItarget PIdata?>"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ENTITY ent1 "This entity should be discarded"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| ]> |
| <!-- This is comment number 1.--> |
| <staff> |
| <employee> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds<![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Yes">&ent2; Dallas, &ent3; |
| 98554</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>&ent4;</gender> |
| <address domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0004</employeeId> |
| <name>Jeny Oconnor</name> |
| <position>Personnel Director</position> |
| <salary>95,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Y&ent1;">27 South Road. Dallas, Texas 98556</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </staff> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/staff2.dtd |
|---|
| 0,0 → 1,24 |
| <!ELEMENT employeeId (#PCDATA)> |
| <!ELEMENT name (#PCDATA)> |
| <!ELEMENT position (#PCDATA)> |
| <!ELEMENT salary (#PCDATA)> |
| <!ELEMENT address (#PCDATA)> |
| <!ELEMENT gender ( #PCDATA)> |
| <!ELEMENT employee (employeeId, name, position, salary, gender, address) > |
| <!ATTLIST employee xmlns CDATA #IMPLIED> |
| <!ELEMENT staff (employee)+> |
| <!ELEMENT svg (rect, script, employee+)> |
| <!ATTLIST svg |
| xmlns CDATA #FIXED "http://www.w3.org/2000/svg" |
| name CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "internalSubset01.js"> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/staff2.svg |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg SYSTEM "staff2.dtd" []> |
| <!-- This is comment number 1.--> |
| <svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <employee xmlns="http://www.example.com"> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address>1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/staff2.xml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE staff SYSTEM "staff2.dtd" []> |
| <!-- This is comment number 1.--> |
| <staff> |
| <employee> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address>1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| </staff> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/staffNS.dtd |
|---|
| 0,0 → 1,45 |
| <!ELEMENT staff (employee+,emp:employee,employee) > |
| <!ELEMENT employee (employeeId,name,position,salary,gender,address) > |
| <!ATTLIST employee xmlns CDATA #IMPLIED> |
| <!ATTLIST employee xmlns:dmstc CDATA #IMPLIED> |
| <!ATTLIST employee xmlns:emp2 CDATA #IMPLIED> |
| <!ELEMENT employeeId (#PCDATA) > |
| <!ELEMENT name (#PCDATA) > |
| <!ELEMENT position (#PCDATA) > |
| <!ELEMENT salary (#PCDATA) > |
| <!ELEMENT entElement1 (#PCDATA) > |
| <!ELEMENT gender (#PCDATA | entElement1)* > |
| <!ATTLIST entElement1 xmlns:local1 CDATA #IMPLIED > |
| <!ELEMENT address (#PCDATA) > |
| <!ATTLIST address dmstc:domestic CDATA #IMPLIED> |
| <!ATTLIST address street CDATA #IMPLIED> |
| <!ATTLIST address domestic CDATA #IMPLIED> |
| <!ATTLIST address xmlns CDATA #IMPLIED> |
| <!ELEMENT emp:employee (emp:employeeId,nm:name,emp:position,emp:salary,emp:gender,emp:address) > |
| <!ATTLIST emp:employee xmlns:emp CDATA #IMPLIED> |
| <!ATTLIST emp:employee xmlns:nm CDATA #IMPLIED> |
| <!ATTLIST emp:employee defaultAttr CDATA 'defaultVal'> |
| <!ELEMENT emp:employeeId (#PCDATA) > |
| <!ELEMENT nm:name (#PCDATA) > |
| <!ELEMENT emp:position (#PCDATA) > |
| <!ELEMENT emp:salary (#PCDATA) > |
| <!ELEMENT emp:gender (#PCDATA) > |
| <!ELEMENT emp:address (#PCDATA) > |
| <!ATTLIST emp:address emp:domestic CDATA #IMPLIED> |
| <!ATTLIST emp:address street CDATA #IMPLIED> |
| <!ATTLIST emp:address emp:zone ID #IMPLIED> |
| <!ATTLIST emp:address emp:district CDATA 'DISTRICT'> |
| <!ATTLIST emp:address emp:local1 CDATA 'FALSE'> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/staffNS.svg |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg PUBLIC "STAFF" "staffNS.dtd" |
| [ |
| <!ENTITY ent1 "es"> |
| <!ENTITY ent2 "1900 Dallas Road"> |
| <!ENTITY ent3 "Texas"> |
| <!ENTITY ent4 "<entElement1 xmlns:local1='www.xyz.com'>Element data</entElement1><?PItarget PIdata?>"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ENTITY ent6 PUBLIC "uri" "file" NDATA notation2> |
| <!ENTITY ent1 "This entity should be discarded"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ELEMENT svg (rect, script, employee+, emp:employee, employee*)> |
| <!ATTLIST svg |
| xmlns CDATA #FIXED "http://www.w3.org/2000/svg" |
| name CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <!-- This is comment number 1.--> |
| <svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <employee xmlns="http://www.nist.gov" xmlns:dmstc="http://www.usa.com"> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address dmstc:domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee xmlns:dmstc="http://www.usa.com" xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2/Files"> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds |
| <![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address dmstc:domestic="Yes" street="Yes">&ent2; Dallas, &ent3; |
| 98554</address> |
| </employee> |
| <employee xmlns:dmstc="http://www.netzero.com" xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2/Files"> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>&ent4;</gender> |
| <address dmstc:domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <emp:employee xmlns:emp="http://www.nist.gov" xmlns:nm="http://www.altavista.com" > <emp:employeeId>EMP0004</emp:employeeId> |
| <nm:name>Jeny Oconnor</nm:name> |
| <emp:position>Personnel Director</emp:position> |
| <emp:salary>95,000</emp:salary> |
| <emp:gender>Female</emp:gender> |
| <emp:address emp:domestic="Yes" street="Y&ent1;" emp:zone="CANADA" emp:local1="TRUE">27 South Road. Dallas, texas 98556</emp:address> |
| </emp:employee> |
| <employee xmlns:emp2="http://www.nist.gov" xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2/Files"> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes" xmlns="http://www.nist.gov">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/staffNS.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE staff PUBLIC "STAFF" "staffNS.dtd" |
| [ |
| <!ENTITY ent1 "es"> |
| <!ENTITY ent2 "1900 Dallas Road"> |
| <!ENTITY ent3 "Texas"> |
| <!ENTITY ent4 "<entElement1 xmlns:local1='www.xyz.com'>Element data</entElement1><?PItarget PIdata?>"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ENTITY ent6 PUBLIC "uri" "file" NDATA notation2> |
| <!ENTITY ent1 "This entity should be discarded"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| ]> |
| <!-- This is comment number 1.--> |
| <staff> |
| <employee xmlns="http://www.nist.gov" xmlns:dmstc="http://www.usa.com"> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address dmstc:domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee xmlns:dmstc="http://www.usa.com"> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds |
| <![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address dmstc:domestic="Yes" street="Yes">&ent2; Dallas, &ent3; |
| 98554</address> |
| </employee> |
| <employee xmlns:dmstc="http://www.netzero.com"> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>&ent4;</gender> |
| <address dmstc:domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <emp:employee xmlns:emp="http://www.nist.gov" xmlns:nm="http://www.altavista.com" > <emp:employeeId>EMP0004</emp:employeeId> |
| <nm:name>Jeny Oconnor</nm:name> |
| <emp:position>Personnel Director</emp:position> |
| <emp:salary>95,000</emp:salary> |
| <emp:gender>Female</emp:gender> |
| <emp:address emp:domestic="Yes" street="Y&ent1;" emp:zone="CANADA" emp:local1="TRUE">27 South Road. Dallas, texas 98556</emp:address> |
| </emp:employee> |
| <employee xmlns:emp2="http://www.nist.gov"> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes" xmlns="http://www.nist.gov">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </staff> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/files/xhtml1-strict.dtd |
|---|
| 0,0 → 1,65 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This is a radically simplified DTD for use in the DOM Test Suites |
| due to a XML non-conformance of one implementation in processing |
| parameter entities. When that non-conformance is resolved, |
| this DTD can be replaced by the normal DTD for XHTML. |
| --> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (meta,title,script*)> |
| <!ELEMENT meta EMPTY> |
| <!ATTLIST meta |
| http-equiv CDATA #IMPLIED |
| content CDATA #IMPLIED> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT body (p*)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|em|strong|code|sup|var|acronym|abbr)*> |
| <!ATTLIST p |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT em (#PCDATA)> |
| <!ELEMENT span (#PCDATA)> |
| <!ELEMENT strong (#PCDATA)> |
| <!ELEMENT code (#PCDATA)> |
| <!ELEMENT sup (#PCDATA)> |
| <!ELEMENT var (#PCDATA|span)*> |
| <!ELEMENT acronym (#PCDATA)> |
| <!ATTLIST acronym |
| title CDATA #IMPLIED |
| class CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT abbr (#PCDATA)> |
| <!ATTLIST abbr |
| title CDATA #IMPLIED |
| class CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| type CDATA #IMPLIED |
| src CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getAttributeNS01.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getAttributeNS01"> |
| <metadata> |
| <title>getAttributeNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributeNS(namespaceURI,localName)" method retrieves an |
| attribute value by local name and NamespaceURI. |
| Retrieve the first "emp:address" element. |
| The value returned by the "getAttributeNS()" method should be the |
| value "DISTRICT" since the attribute has a default value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAttrNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=238"/> |
| </metadata> |
| <!-- test requires namespace awareness and validation --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="localName" type="DOMString" value=""district""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:district""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""emp:address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <getAttributeNS obj="testAddr" var="attrValue" namespaceURI="namespaceURI" localName="localName"/> |
| <assertEquals actual="attrValue" expected='"DISTRICT"' id="attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getAttributeNS02.xml.unknown |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getAttributeNS02"> |
| <metadata> |
| <title>getAttributeNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributeNS(namespaceURI,localName)" method retrieves an |
| attribute value by local name and NamespaceURI. |
| Retrieve the first "emp:address" element. |
| Create a new attribute with the "createAttributeNS()" method. |
| Add the new attribute with the "setAttributeNS()" method. |
| The value returned by the "getAttributeNS()" method should be the |
| empty string since the attribute does not have a default value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAttrNS"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="localName" type="DOMString" value=""district""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:district""/> |
| <var name="doc" type="Document"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="districtAttr" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createAttributeNS obj="doc" var="newAttribute" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""emp:address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <setAttributeNodeNS obj="testAddr" var="districtAttr" newAttr="newAttribute"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""emp:address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <getAttributeNS obj="testAddr" var="attrValue" namespaceURI="namespaceURI" localName="localName"/> |
| <assertEquals actual="attrValue" expected="""" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getAttributeNS03.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getAttributeNS03"> |
| <metadata> |
| <title>getAttributeNS03</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributeNS(namespaceURI,localName)" method retrieves an |
| attribute value by local name and NamespaceURI. |
| Retrieve the first "emp:address" element. |
| The value returned by the "getAttributeNS()" method for the emp:domestic attribute |
| should be the empty string since the attribute does not have a specified value |
| because it was removed by the "removeAttributeNS()" method. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAttrNS"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="localName" type="DOMString" value=""domestic""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""emp:address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <removeAttributeNS obj="testAddr" namespaceURI="namespaceURI" localName="localName"/> |
| <getAttributeNS obj="testAddr" var="attrValue" namespaceURI="namespaceURI" localName="localName"/> |
| <assertEquals actual="attrValue" expected="""" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getAttributeNS04.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getAttributeNS04"> |
| <metadata> |
| <title>getAttributeNS04</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributeNS(namespaceURI,localName)" method retrieves an |
| attribute value by local name and NamespaceURI. |
| Retrieve the first "emp:address" element. |
| Create a new attribute with the "createAttributeNS()" method. |
| Add the new attribute and value with the "setAttributeNS()" method. |
| The value returned by the "getAttributeNS()" method should be |
| the string "NewValue" since the attribute had a specified value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAttrNS"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="localName" type="DOMString" value=""blank""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:blank""/> |
| <var name="doc" type="Document"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="districtAttr" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createAttributeNS obj="doc" var="newAttribute" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""emp:address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <setAttributeNS obj="testAddr" namespaceURI="namespaceURI" qualifiedName="qualifiedName" value=""NewValue""/> |
| <getAttributeNS obj="testAddr" var="attrValue" namespaceURI="namespaceURI" localName="localName"/> |
| <assertEquals actual="attrValue" expected=""NewValue"" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getAttributeNS05.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getAttributeNS05"> |
| <metadata> |
| <title>getAttributeNS05</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributeNS(namespaceURI,localName)" method retrieves an |
| attribute value by local name and NamespaceURI. |
| Retrieve the first emp:address element node |
| and retrieve the emp:domestic attribute. The method returns an |
| Attr value as a string, the "value" can be examined to ensure the |
| proper attribute value was retrieved. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAttrNS"/> |
| </metadata> |
| <!-- test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="attrValue" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"emp:address"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <getAttributeNS obj="testAddr" var="attrValue" namespaceURI='"http://www.nist.gov"' localName='"domestic"'/> |
| <assertEquals actual="attrValue" expected='"Yes"' id="attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getAttributeNodeNS01.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getAttributeNodeNS01"> |
| <metadata> |
| <title>getAttributeNodeNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributeNodeNS(namespaceURI,localName)" method retrieves an |
| attribute node by local name and NamespaceURI. |
| Retrieve the first emp:address element node. |
| The getAttributeNodeNS method returns an |
| Attr node, the "value" can be examined to ensure the |
| proper attribute node was retrieved. This attribute |
| value should be null since there is no such attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAtNodeNS"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="localName" type="DOMString" value=""invalidlocalname""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""emp:address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <getAttributeNodeNS obj="testAddr" var="attribute" namespaceURI="namespaceURI" localName="localName"/> |
| <assertNull actual="attribute" id="throw_Null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getAttributeNodeNS02.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getAttributeNodeNS02"> |
| <metadata> |
| <title>getAttributeNodeNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "getAttributeNodeNS(namespaceURI,localName)" method retrieves an |
| attribute node by local name and NamespaceURI. |
| Retrieve the first emp:address element node. |
| The getAttributeNodeNS method returns an |
| Attr node, the "value" can be examined to ensure the |
| proper attribute node was retrieved. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-F68D095"/> |
| </metadata> |
| <!-- this test requires a namespace aware processor --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"emp:address"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <getAttributeNodeNS obj="testAddr" var="attribute" namespaceURI='"http://www.nist.gov"' localName='"domestic"'/> |
| <nodeName obj="attribute" var="attrName"/> |
| <assertEquals actual="attrName" expected='"emp:domestic"' id="attrName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementById01.xml.kfail |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementById01"> |
| <metadata> |
| <title>getElementById01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementById(elementId)" method for a |
| Document should return an element whose ID matches elementId. |
| Invoke method getElementById(elementId) on this document |
| with elementId equals "CANADA". Method should return an element |
| whose tag name is "emp:address". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-104682815"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=383"/> |
| </metadata> |
| <!-- unless validating, parser is not assured of knowing what attributes |
| are of type ID --> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="tagname" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementById interface="Document" obj="doc" var="element" elementId=""CANADA""/> |
| <tagName obj="element" var="tagname"/> |
| <assertEquals actual="tagname" expected=""emp:address"" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementById02.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementById02"> |
| <metadata> |
| <title>getElementById02</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementById(elementId)" method for a |
| Document should return null if elementId does not identify any |
| elements in this document. |
| Invoke method getElementById(elementId) on this document |
| with elementId equals "Cancun". Method should return null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBId"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementById interface="Document" obj="doc" var="element" elementId=""Cancun""/> |
| <assertNull actual="element" id="throw_Null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS01.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS01"> |
| <metadata> |
| <title>getElementsByTagNameNS01</title> |
| <creator>NIST</creator> |
| <description> |
| Invoke method getElementsByTagNameNS(namespaceURI,localName) on this document |
| with namespaceURI and localName as "*" and check size of returned node list. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""*""/> |
| <var name="localName" type="DOMString" value=""*""/> |
| <var name="doc" type="Document"/> |
| <var name="newList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS interface="Document" obj="doc" var="newList" namespaceURI="namespaceURI" localName="localName"/> |
| <if><contentType type="image/svg+xml"/> |
| <assertSize collection="newList" size="39" id="listLength_svg"/> |
| <else> |
| <assertSize collection="newList" size="37" id="listLength"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS02.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS02"> |
| <metadata> |
| <title>getElementsByTagNameNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method for a |
| Document should return a new NodeList of all Elements with a given |
| localName and namespaceURI in the order they were encountered in a preorder |
| traversal of the document tree. |
| Invoke method getElementsByTagNameNS(namespaceURI,localName) on this document |
| with namespaceURI being " " and localName is "employee". |
| Method should return a new NodeList containing five Elements. |
| Retrieve the FOURTH element whose name should be "emp:employee". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <!-- this test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newList" type="NodeList"/> |
| <var name="newElement" type="Element"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="lname" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS interface="Document" obj="doc" var="newList" namespaceURI='"*"' localName='"employee"'/> |
| <assertSize collection="newList" size="5" id="employeeCount"/> |
| <item interface="NodeList" obj="newList" var="newElement" index="3"/> |
| <prefix obj="newElement" var="prefix"/> |
| <assertEquals actual="prefix" expected='"emp"' id="prefix" ignoreCase="false"/> |
| <localName obj="newElement" var="lname"/> |
| <assertEquals actual="lname" expected='"employee"' id="lname" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS03.xml.unknown |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS03"> |
| <metadata> |
| <title>getElementsByTagNameNS03</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method returns a NodeList |
| of all descendant Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of this Element tree. |
| Create a NodeList of all the descendant elements |
| using the "http://www.nist.gov" as the namespaceURI and the special value " " as the |
| localName. |
| The method should return a NodeList of elements that have "http://www.nist.gov |
| as a namespace URI. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <!-- test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="expectedResult" type="List"> |
| <member>"employee"</member> |
| <member>"employeeId"</member> |
| <member>"name"</member> |
| <member>"position"</member> |
| <member>"salary"</member> |
| <member>"gender"</member> |
| <member>"address"</member> |
| <member>"emp:employee"</member> |
| <member>"emp:employeeId"</member> |
| <member>"emp:position"</member> |
| <member>"emp:salary"</member> |
| <member>"emp:gender"</member> |
| <member>"emp:address"</member> |
| <member>"address"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS interface="Document" obj="doc" namespaceURI='"http://www.nist.gov"' localName='"*"' var="elementList"/> |
| <for-each collection="elementList" member="child"> |
| <nodeName obj="child" var="childName"/> |
| <append collection="result" item="childName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedResult" id="nodeNames" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS04.xml.unknown |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS04"> |
| <metadata> |
| <title>getElementsByTagNameNS04</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method returns a NodeList |
| of all descendant Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of this Element tree. |
| Create a NodeList of all the descendant elements |
| using the special value " " as the namespaceURI and "address" as the |
| localName. |
| The method should return a NodeList of Elements that have |
| "address" as the local name. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="expectedResult" type="List"> |
| <member>"address"</member> |
| <member>"address"</member> |
| <member>"address"</member> |
| <member>"emp:address"</member> |
| <member>"address"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS interface="Document" obj="doc" namespaceURI='"*"' localName='"address"' var="elementList"/> |
| <for-each collection="elementList" member="child"> |
| <nodeName obj="child" var="childName"/> |
| <append collection="result" item="childName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedResult" id="nodeNames" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS05.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS05"> |
| <metadata> |
| <title>getElementsByTagNameNS05</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method returns a NodeList |
| of all descendant Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of this Element tree. |
| Create a NodeList of all the descendant elements |
| using the "http://www.nist.gov" as the namespaceURI and "nomatch" as the |
| localName. |
| The method should return a NodeList whose length is |
| "0". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="localName" type="DOMString" value=""nomatch""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS interface="Document" obj="doc" namespaceURI="namespaceURI" localName="localName" var="elementList"/> |
| <assertSize collection="elementList" size="0" id="throw_Size"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS06.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS06"> |
| <metadata> |
| <title>getElementsByTagNameNS06</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method returns a NodeList |
| of all descendant Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of this Element tree. |
| Create a NodeList of all the descendant elements |
| using the "http://www.nomatch.com" as the namespaceURI and "address" as the |
| localName. |
| The method should return a NodeList whose length is |
| "0". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <!-- test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS interface="Document" obj="doc" namespaceURI='"http://www.nomatch.com"' localName='"address"' var="elementList"/> |
| <assertSize collection="elementList" size="0" id="matchSize"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS07.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS07"> |
| <metadata> |
| <title>getElementsByTagNameNS07</title> |
| <creator>NIST</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method returns a NodeList |
| of all descendant Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of this Element tree. |
| Create a NodeList of all the descendant elements |
| using the string "http://www.nist.gov" as the namespaceURI and "address" as the |
| localName. |
| The method should return a NodeList whose length is |
| "3". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getElBTNNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS interface="Document" obj="doc" namespaceURI='"http://www.nist.gov"' localName='"address"' var="elementList"/> |
| <assertSize collection="elementList" size="3" id="addresses"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS08.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS08"> |
| <metadata> |
| <title>getElementsByTagNameNS08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Element.getElementsByTagNameNS('*','*') should return all child |
| elements. There is some contention on whether this should match |
| unqualified elements, this test reflects the interpretation that |
| '*' should match elements in all namespaces and unqualified elements. |
| Derived from getElementsByTagNameNS01 which tests similar functionality |
| on the Document interface. |
| </description> |
| <date qualifier="created">2001-02-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1938918D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="newList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getElementsByTagNameNS interface="Element" obj="docElem" var="newList" namespaceURI='"*"' localName='"*"'/> |
| <if><contentType type="image/svg+xml"/> |
| <assertSize collection="newList" size="38" id="listSize_svg"/> |
| <else> |
| <assertSize collection="newList" size="36" id="listSize"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS09.xml.unknown |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS09"> |
| <metadata> |
| <title>getElementsByTagNameNS09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method for a |
| Element should return a new NodeList of all descendant Elements with a given |
| localName and namespaceURI in the order they were encountered in a preorder |
| traversal of the document tree. |
| Invoke method getElementsByTagNameNS(namespaceURI,localName) on the document |
| element with namespaceURI being "*" and localName is "employee". |
| Method should return a new NodeList containing five Elements. |
| Retrieve the FOURTH element whose name should be "emp:employee". |
| Derived from getElementsByTagNameNS02 and reflects its interpretation |
| that namespace="*" matches namespace unqualified tagnames. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2001-02-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1938918D"/> |
| </metadata> |
| <!-- this test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newList" type="NodeList"/> |
| <var name="newElement" type="Element"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="lname" type="DOMString"/> |
| <var name="docElem" type="Element"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getElementsByTagNameNS interface="Element" obj="docElem" var="newList" namespaceURI='"*"' localName='"employee"'/> |
| <assertSize collection="newList" size="5" id="employeeCount"/> |
| <item interface="NodeList" obj="newList" var="newElement" index="3"/> |
| <prefix obj="newElement" var="prefix"/> |
| <assertEquals actual="prefix" expected='"emp"' id="prefix" ignoreCase="false"/> |
| <localName obj="newElement" var="lname"/> |
| <assertEquals actual="lname" expected='"employee"' id="lname" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS10.xml.unknown |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS10"> |
| <metadata> |
| <title>getElementsByTagNameNS10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method returns a NodeList |
| of all descendant Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of this Element tree. |
| Create a NodeList of all the descendant elements of the document element |
| using the "http://www.nist.gov" as the namespaceURI and the special value "*" as the |
| localName. |
| The method should return a NodeList of elements that have "http://www.nist.gov |
| as a namespace URI. |
| Derived from getElementsByTagNameNS03 |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-02-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1938918D"/> |
| </metadata> |
| <!-- test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="expectedResult" type="List"> |
| <member>"employee"</member> |
| <member>"employeeId"</member> |
| <member>"name"</member> |
| <member>"position"</member> |
| <member>"salary"</member> |
| <member>"gender"</member> |
| <member>"address"</member> |
| <member>"emp:employee"</member> |
| <member>"emp:employeeId"</member> |
| <member>"emp:position"</member> |
| <member>"emp:salary"</member> |
| <member>"emp:gender"</member> |
| <member>"emp:address"</member> |
| <member>"address"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getElementsByTagNameNS interface="Element" obj="docElem" namespaceURI='"http://www.nist.gov"' localName='"*"' var="elementList"/> |
| <for-each collection="elementList" member="child"> |
| <nodeName obj="child" var="childName"/> |
| <append collection="result" item="childName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedResult" id="nodeNames" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS11.xml.unknown |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS11"> |
| <metadata> |
| <title>getElementsByTagNameNS11</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method returns a NodeList |
| of all descendant Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of this Element tree. |
| Create a NodeList of all the descendant elements |
| using the special value "*" as the namespaceURI and "address" as the |
| localName. |
| The method should return a NodeList of Elements that have |
| "address" as the local name. |
| This test is derived from getElementsByTagNameNS04 |
| </description> |
| <date qualifier="created">2002-02-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1938918D"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="expectedResult" type="List"> |
| <member>"address"</member> |
| <member>"address"</member> |
| <member>"address"</member> |
| <member>"emp:address"</member> |
| <member>"address"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getElementsByTagNameNS interface="Element" obj="docElem" namespaceURI='"*"' localName='"address"' var="elementList"/> |
| <for-each collection="elementList" member="child"> |
| <nodeName obj="child" var="childName"/> |
| <append collection="result" item="childName"/> |
| </for-each> |
| <assertEquals actual="result" expected="expectedResult" id="nodeNames" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS12.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS12"> |
| <metadata> |
| <title>getElementsByTagNameNS12</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method returns a NodeList |
| of all descendant Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of this Element tree. |
| Create a NodeList of all the descendant elements |
| using the "http://www.nist.gov" as the namespaceURI and "nomatch" as the |
| localName. |
| The method should return a NodeList whose length is "0". |
| This test is a modification of getElementsByTagName05 |
| </description> |
| <date qualifier="created">2001-02-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1938918D"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getElementsByTagNameNS interface="Element" obj="docElem" namespaceURI='"http://www.nist.gov"' localName='"nomatch"' var="elementList"/> |
| <assertSize collection="elementList" size="0" id="size"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS13.xml.unknown |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS13"> |
| <metadata> |
| <title>getElementsByTagNameNS13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method returns a NodeList |
| of all descendant Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of this Element tree. |
| Create a NodeList of all the descendant elements |
| using the "http://www.nomatch.com" as the namespaceURI and "address" as the |
| localName. |
| The method should return a NodeList whose length is |
| "0". |
| </description> |
| <date qualifier="created">2001-02-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1938918D"/> |
| </metadata> |
| <!-- test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getElementsByTagNameNS interface="Element" obj="docElem" namespaceURI='"http://www.nomatch.com"' localName='"address"' var="elementList"/> |
| <assertSize collection="elementList" size="0" id="matchSize"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getElementsByTagNameNS14.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getElementsByTagNameNS14"> |
| <metadata> |
| <title>getElementsByTagNameNS14</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The "getElementsByTagNameNS(namespaceURI,localName)" method returns a NodeList |
| of all descendant Elements with a given local name and namespace URI in the |
| order in which they are encountered in a preorder traversal of this Element tree. |
| Create a NodeList of all the descendant elements |
| using the string "http://www.nist.gov" as the namespaceURI and "address" as the |
| localName. |
| The method should return a NodeList whose length is |
| "3". |
| </description> |
| <date qualifier="created">2002-02-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1938918D"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getElementsByTagNameNS interface="Element" obj="docElem" namespaceURI='"http://www.nist.gov"' localName='"address"' var="elementList"/> |
| <assertSize collection="elementList" size="3" id="addresses"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getNamedItemNS01.xml.unknown |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getNamedItemNS01"> |
| <metadata> |
| <title>getNamedItemNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNamedItemNS(namespaceURI,localName)" method for a |
| NamedNodeMap should return a node specified by localName and namespaceURI |
| Retrieve a list of elements with tag name "address". |
| Access the second element from the list and get its attributes. |
| Try to retrieve the attribute node with local name "domestic" |
| and namespace uri "http://www.usa.com" with |
| method getNamedItemNS(namespaceURI,localName). |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-F68D095"/> |
| </metadata> |
| <!-- this test requires the parser to be namespace aware --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"address"'/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="1"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItemNS obj="attributes" var="domesticAttr" namespaceURI='"http://www.usa.com"' localName='"domestic"'/> |
| <nodeName obj="domesticAttr" var="attrName"/> |
| <assertEquals actual="attrName" expected='"dmstc:domestic"' id="attrName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getNamedItemNS02.xml.unknown |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getNamedItemNS02"> |
| <metadata> |
| <title>getNamedItemNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNamedItemNS(namespaceURI,localName)" method for a |
| NamedNodeMap should return null |
| if parameters do not identify any node in this map. |
| Retrieve a list of elements with tag name "address". |
| Access the second element from the list and get its attributes. |
| Try to retrieve an attribute node with local name "domest" |
| and namespace uri "http://www.usa.com" with |
| method getNamedItemNS(namespaceURI,localName). |
| This should return null because "domest" does not match any local names in this map. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getNamedItemNS"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.usa.com""/> |
| <var name="localName" type="DOMString" value=""domest""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="newAttr" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testEmployee" index="1"/> |
| <attributes obj="testEmployee" var="attributes"/> |
| <getNamedItemNS obj="attributes" var="newAttr" namespaceURI="namespaceURI" localName="localName"/> |
| <assertNull actual="newAttr" id="throw_Null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getNamedItemNS03.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getNamedItemNS03"> |
| <metadata> |
| <title>getNamedItemNS03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Entity nodes are not namespaced and should not be retrievable using |
| getNamedItemNS. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2003-11-26</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getNamedItemNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entities" obj="docType"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <getNamedItemNS var="entity" obj="entities" namespaceURI="nullNS" localName='"ent1"'/> |
| <assertNull actual="entity" id="entityNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/getNamedItemNS04.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="getNamedItemNS04"> |
| <metadata> |
| <title>getNamedItemNS04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Notation nodes are not namespaced and should not be retrievable using |
| getNamedItemNS. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2003-11-26</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getNamedItemNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notations" obj="docType"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItemNS var="notation" obj="notations" namespaceURI="nullNS" localName='"notation1"'/> |
| <assertNull actual="notation" id="notationNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttribute01.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttribute01"> |
| <metadata> |
| <title>hasAttribute01</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttribute()" method for an Element should |
| return true if the element has an attribute with the given name. |
| Retrieve the first "address" element and the "hasAttribute()" method |
| should return false since the element does not have a default value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testNode" type="Element"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="4"/> |
| <hasAttribute obj="testNode" var="state" name=""domestic""/> |
| <assertFalse actual="state" id="throw_False"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttribute02.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttribute02"> |
| <metadata> |
| <title>hasAttribute02</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttribute()" method for an Element should |
| return true if the element has an attribute with the given name. |
| Retrieve the first "address" element and the "hasAttribute()" method |
| should return true since the attribute "street" has a default value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttr"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=238"/> |
| </metadata> |
| <!-- only mandatory for validating parsers --> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testNode" type="Element"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="0"/> |
| <hasAttribute obj="testNode" var="state" name=""street""/> |
| <assertTrue actual="state" id="throw_True"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttribute03.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttribute03"> |
| <metadata> |
| <title>hasAttribute03</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttribute()" method for an Element should |
| return false if the element does not have an attribute with the given name. |
| Retrieve the first "address" element and the "hasAttribute()" method |
| should return false since the element does not have "nomatch" as an attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testNode" type="Element"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="0"/> |
| <hasAttribute obj="testNode" var="state" name=""nomatch""/> |
| <assertFalse actual="state" id="throw_False"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttribute04.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttribute04"> |
| <metadata> |
| <title>hasAttribute04</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttribute()" method for an Element should |
| return true if the element has an attribute with the given name. |
| Retrieve the first "address" element and the "hasAttribute()" method |
| should return true since the element has "domestic" as an attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttr"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=238"/> |
| </metadata> |
| <!-- only mandatory for validating parsers --> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testNode" type="Element"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"address"'/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="0"/> |
| <hasAttribute obj="testNode" var="state" name='"dmstc:domestic"'/> |
| <assertTrue actual="state" id="hasDomesticAttr"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttributeNS01.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttributeNS01"> |
| <metadata> |
| <title>hasAttributeNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttributeNS()" method for an Element should |
| return false if the element does not have an attribute with the given local name |
| and/or a namespace URI specified on this element or does not have a default value. |
| Retrieve the first "address" element and the "hasAttributeNS()" method |
| should return false since the element has "nomatch" as the local name |
| and "http://www.usa.com" as the namespace URI. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttrNS"/> |
| </metadata> |
| <var name="localName" type="DOMString" value=""nomatch""/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.usa.com""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testNode" type="Element"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="0"/> |
| <hasAttributeNS obj="testNode" var="state" namespaceURI="namespaceURI" localName="localName"/> |
| <assertFalse actual="state" id="throw_False"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttributeNS02.xml.unknown |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttributeNS02"> |
| <metadata> |
| <title>hasAttributeNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttributeNS()" method for an Element should |
| return false if the element does not have an attribute with the given local name |
| and/or namespace URI specified on this element or does not have a default value. |
| Retrieve the first "address" element and the "hasAttributeNS()" method |
| should return false since the element has "domestic" as the local name |
| and "http://www.nomatch.com" as the namespace URI. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttrNS"/> |
| </metadata> |
| <var name="localName" type="DOMString" value=""domestic""/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nomatch.com""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testNode" type="Element"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="0"/> |
| <hasAttributeNS obj="testNode" var="state" namespaceURI="namespaceURI" localName="localName"/> |
| <assertFalse actual="state" id="throw_False"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttributeNS03.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttributeNS03"> |
| <metadata> |
| <title>hasAttributeNS03</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttributeNS()" method for an Element should |
| return false if the element does not have an attribute with the given local name |
| and/or namespace URI specified on this element or does not have a default value. |
| Retrieve the first "emp:address" element. |
| The boolean value returned by the "hasAttributeNS()" should be false |
| since the attribute does not have a default value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttrNS"/> |
| </metadata> |
| <var name="localName" type="DOMString" value=""blank""/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testNode" type="Element"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""emp:address""/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="0"/> |
| <assertNotNull actual="testNode" id="empAddrNotNull"/> |
| <hasAttributeNS obj="testNode" var="state" namespaceURI="namespaceURI" localName="localName"/> |
| <assertFalse actual="state" id="throw_False"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttributeNS04.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttributeNS04"> |
| <metadata> |
| <title>hasAttributeNS04</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttributeNS()" method for an Element should |
| return true if the attribute with the given local name |
| and namespace URI has a default value. |
| Retrieve the first "emp:address" element. |
| The boolean value returned by the "hasAttributeNS()" should be true |
| since the attribute has a default value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttrNS"/> |
| </metadata> |
| <!-- test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="localName" type="DOMString" value=""district""/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testNode" type="Element"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""emp:address""/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="0"/> |
| <assertNotNull actual="testNode" id="empAddressNotNull"/> |
| <hasAttributeNS obj="testNode" var="state" namespaceURI="namespaceURI" localName="localName"/> |
| <assertTrue actual="state" id="hasAttribute"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttributeNS05.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttributeNS05"> |
| <metadata> |
| <title>hasAttributeNS05</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttributeNS()" method for an Element should |
| return true if the element has an attribute with the given local name |
| and the namespace URI is specified on this element or has a default value. |
| Retrieve the first "address" element and the "hasAttributeNS()" method |
| should return true since the element has "domestic" as the local name |
| and "http://www.usa.com" as the namespace URI. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElHasAttrNS"/> |
| </metadata> |
| <!-- test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="localName" type="DOMString" value=""domestic""/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.usa.com""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testNode" type="Element"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testNode" index="0"/> |
| <hasAttributeNS obj="testNode" var="state" namespaceURI="namespaceURI" localName="localName"/> |
| <assertTrue actual="state" id="hasAttribute"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttributes01.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttributes01"> |
| <metadata> |
| <title>hasAttributes01</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttributes()" method for a node should |
| return false if the node does not have an attribute. |
| Retrieve the first "name" node and invoke the "hasAttributes()" method. |
| The method should return false since the node does not have an attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeHasAttrs"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addrList" type="NodeList"/> |
| <var name="addrNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""name"" var="addrList"/> |
| <item interface="NodeList" obj="addrList" index="0" var="addrNode"/> |
| <hasAttributes obj="addrNode" var="state"/> |
| <assertFalse actual="state" id="throw_False"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hasAttributes02.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasAttributes02"> |
| <metadata> |
| <title>hasAttributes02</title> |
| <creator>NIST</creator> |
| <description> |
| The "hasAttributes()" method for a node should |
| return true if the node has attributes. |
| Retrieve the first address node and the "hasAttributes()" method |
| should return true since the node has "domestic" as an attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeHasAttrs"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addrList" type="NodeList"/> |
| <var name="addrNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""address"" var="addrList"/> |
| <item interface="NodeList" obj="addrList" index="0" var="addrNode"/> |
| <hasAttributes obj="addrNode" var="state"/> |
| <assertTrue actual="state" id="throw_True"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hc_entitiesremovenameditemns1.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hc_entitiesremovenameditemns1"> |
| <metadata> |
| <title>hc_entitiesremovenameditemns1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An attempt to add remove an entity using removeNamedItemNS should result in |
| a NO_MODIFICATION_ERR or a NOT_FOUND_ERR. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <!-- DocumentType.entities --> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1788794630"/> |
| <!-- NamedNodeMap.removeNamedItemNS --> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-removeNamedItemNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities var="entities" obj="docType"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <try> |
| <removeNamedItemNS var="retval" obj="entities" namespaceURI='"http://www.w3.org/1999/xhtml"' localName='"alpha"'/> |
| <fail id="throw_NO_MOD_OR_NOT_FOUND_ERR"/> |
| <catch> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| <DOMException code="NOT_FOUND_ERR"/> |
| </catch> |
| </try> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hc_entitiessetnameditemns1.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hc_entitiessetnameditemns1"> |
| <metadata> |
| <title>hc_entitiessetnameditemns1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An attempt to add an element to the named node map returned by entities should |
| result in a NO_MODIFICATION_ERR or HIERARCHY_REQUEST_ERR. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <!-- DocumentType.entities --> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1788794630"/> |
| <!-- NamedNodeMap.setNamedItemNS --> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="retval" type="Node"/> |
| <var name="elem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities var="entities" obj="docType"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"br"'/> |
| <try> |
| <setNamedItemNS var="retval" obj="entities" arg="elem"/> |
| <fail id="throw_HIER_OR_NO_MOD_ERR"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| </catch> |
| </try> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hc_namednodemapinvalidtype1.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hc_namednodemapinvalidtype1"> |
| <metadata> |
| <title>hc_namednodemapinvalidtype1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to insert an element into an attribute list, |
| should raise a HIERARCHY_REQUEST_ERR. |
| </description> |
| <date qualifier="created">2004-01-09</date> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#xpointer(id('ID-258A00AF')/constant[@name='HIERARCHY_REQUEST_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-1025163788"/> |
| <subject resource="http://www.w3.org/2000/11/DOM-Level-2-errata#core-4"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="docElem" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <attributes var="attributes" obj="docElem"/> |
| <createElement var="newElem" obj="doc" tagName='"html"'/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <setNamedItem var="retval" obj="attributes" arg="newElem"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hc_nodedocumentfragmentnormalize1.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hc_nodedocumentfragmentnormalize1"> |
| <metadata> |
| <title>hc_nodedocumentfragmentnormalize1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a document fragment with two adjacent text nodes, normalize and see if the text nodes |
| were combined. |
| </description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-B63ED1A3"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="txtNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="docFragment"/> |
| <createTextNode var="txtNode" obj="doc" data='"foo"'/> |
| <appendChild var="retval" obj="docFragment" newChild="txtNode"/> |
| <createTextNode var="txtNode" obj="doc" data='"bar"'/> |
| <appendChild var="retval" obj="docFragment" newChild="txtNode"/> |
| <normalize obj="docFragment"/> |
| <firstChild var="txtNode" obj="docFragment" interface="Node"/> |
| <nodeValue obj="txtNode" var="nodeValue"/> |
| <assertEquals actual="nodeValue" expected='"foobar"' id="normalizedNodeValue" ignoreCase="false"/> |
| <nextSibling var="retval" obj="txtNode" interface="Node"/> |
| <assertNull actual="retval" id="singleChild"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hc_nodedocumentfragmentnormalize2.xml.unknown |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hc_nodedocumentfragmentnormalize2"> |
| <metadata> |
| <title>hc_nodedocumentfragmentnormalize1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a document fragment with an empty text node, after normalization there should be no child nodes. |
| were combined. |
| </description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-F68D095"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-B63ED1A3"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="txtNode" type="Text"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment obj="doc" var="docFragment"/> |
| <createTextNode var="txtNode" obj="doc" data='""'/> |
| <appendChild var="retval" obj="docFragment" newChild="txtNode"/> |
| <normalize obj="docFragment"/> |
| <firstChild var="txtNode" obj="docFragment" interface="Node"/> |
| <assertNull actual="txtNode" id="noChild"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hc_notationsremovenameditemns1.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hc_notationsremovenameditemns1"> |
| <metadata> |
| <title>hc_notationsremovenameditemns1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An attempt to add remove an notation using removeNamedItemNS should result in |
| a NO_MODIFICATION_ERR or a NOT_FOUND_ERR. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <!-- DocumentType.notations --> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-D46829EF"/> |
| <!-- NamedNodeMap.removeNamedItemNS --> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-removeNamedItemNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations var="notations" obj="docType"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <try> |
| <removeNamedItemNS var="retval" obj="notations" namespaceURI='"http://www.w3.org/1999/xhtml"' localName='"alpha"'/> |
| <fail id="throw_NO_MOD_OR_NOT_FOUND_ERR"/> |
| <catch> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| <DOMException code="NOT_FOUND_ERR"/> |
| </catch> |
| </try> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/hc_notationssetnameditemns1.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hc_notationssetnameditemns1"> |
| <metadata> |
| <title>hc_notationssetnameditemns1</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An attempt to add an element to the named node map returned by notations should |
| result in a NO_MODIFICATION_ERR or HIERARCHY_REQUEST_ERR. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <!-- DocumentType.notations --> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-D46829EF"/> |
| <!-- NamedNodeMap.setNamedItemNS --> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="retval" type="Node"/> |
| <var name="elem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <if><not><contentType type="text/html"/></not> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <notations var="notations" obj="docType"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"br"'/> |
| <try> |
| <setNamedItemNS var="retval" obj="notations" arg="elem"/> |
| <fail id="throw_HIER_OR_NO_MOD_ERR"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| </catch> |
| </try> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode01.xml.unknown |
|---|
| 0,0 → 1,82 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode01"> |
| <metadata> |
| <title>importNode01</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Attr. |
| The ownerElement is set to null. Specified flag is set to true. |
| Children is imported. |
| Create a new attribute whose name is "elem:attr1" in a different document. |
| Create a child Text node with value "importedText" for the attribute node above. |
| Invoke method importNode(importedNode,deep) on this document with |
| importedNode being the newly created attribute. |
| Method should return a node whose name matches "elem:attr1" and a child node |
| whose value equals "importedText". |
| The returned node should belong to this document whose systemId is "staff.dtd" |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="importedChild" type="Text"/> |
| <var name="aNode" type="Node"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="attrOwnerElement" type="Element"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <var name="specified" type="boolean"/> |
| <var name="childList" type="NodeList"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="child" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="result" type="List"/> |
| <var name="expectedResult" type="List"> |
| <member>"elem:attr1"</member> |
| <member>"importedText"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <createAttribute obj="aNewDoc" var="newAttr" name='"elem:attr1"'/> |
| <createTextNode obj="aNewDoc" var="importedChild" data='"importedText"'/> |
| <appendChild obj="newAttr" var="aNode" newChild="importedChild"/> |
| <importNode obj="doc" var="aNode" importedNode="newAttr" deep="false"/> |
| <ownerDocument obj="aNode" var="ownerDocument"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertNotNull actual="aNode" id="aNode"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="systemId"/> |
| <ownerElement obj="aNode" var="attrOwnerElement"/> |
| <assertNull actual="attrOwnerElement" id="ownerElement"/> |
| <specified obj="aNode" var="specified"/> |
| <assertTrue actual="specified" id="specified"/> |
| <childNodes obj="aNode" var="childList"/> |
| <assertSize collection="childList" size="1" id="childList"/> |
| <nodeName obj="aNode" var="nodeName"/> |
| <assertEquals actual="nodeName" id="nodeName" ignoreCase="false" expected='"elem:attr1"'/> |
| <firstChild interface="Node" obj="aNode" var="child"/> |
| <nodeValue obj="child" var="childValue"/> |
| <assertEquals actual="childValue" id="childValue" ignoreCase="false" expected='"importedText"'/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode02.xml.unknown |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode02"> |
| <metadata> |
| <title>importNode02</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type CData_Section. |
| Create a CDATASection node with value being the string "this is CDATASection data" in |
| a different document. Invoke method importNode(importedNode,deep) on |
| this document. Method should return a CDATASection node whose value matches |
| the above string. The returned node should belong to this document whose systemId is "staff.dtd" |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="cDataSec" type="CDATASection"/> |
| <var name="aNode" type="Node"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <createCDATASection obj="aNewDoc" var="cDataSec" data='"this is CDATASection data"'/> |
| <importNode obj="doc" var="aNode" importedNode="cDataSec" deep="false"/> |
| <ownerDocument obj="aNode" var="ownerDocument"/> |
| <assertNotNull actual="ownerDocument" id="ownerDocumentNotNull"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="dtdSystemId"/> |
| <nodeValue obj="aNode" var="value"/> |
| <assertEquals actual="value" expected='"this is CDATASection data"' id="nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode03.xml.unknown |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode03"> |
| <metadata> |
| <title>importNode03</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Comment. |
| Create a comment node with value being the string "this is a comment" in |
| a different document. Invoke method importNode(importedNode,deep) on |
| this document. Method should return a comment node whose value matches |
| the above string. The returned node should belong to this document whose |
| systemId is "staff.dtd" |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="comment" type="Comment"/> |
| <var name="aNode" type="Node"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <createComment obj="aNewDoc" var="comment" data='"this is a comment"'/> |
| <importNode obj="doc" var="aNode" importedNode="comment" deep="false"/> |
| <ownerDocument obj="aNode" var="ownerDocument"/> |
| <assertNotNull actual="ownerDocument" id="ownerDocumentNotNull"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="systemId"/> |
| <nodeValue obj="aNode" var="value"/> |
| <assertEquals actual="value" expected='"this is a comment"' id="nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode04.xml.unknown |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode04"> |
| <metadata> |
| <title>importNode04</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Document_Fragment. |
| Create a DocumentFragment in a different document. |
| Create a Comment child node for the Document Fragment. |
| Invoke method importNode(importedNode,deep) on this document |
| with importedNode being the newly created DocumentFragment. |
| Method should return a node of type DocumentFragment whose child has |
| comment value "descendant1". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="comment" type="Comment"/> |
| <var name="aNode" type="Node"/> |
| <var name="children" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <load var="aNewDoc" href="staff" willBeModified="true"/> |
| <createDocumentFragment obj="aNewDoc" var="docFrag"/> |
| <createComment obj="aNewDoc" var="comment" data='"descendant1"'/> |
| <appendChild obj="docFrag" var="aNode" newChild="comment"/> |
| <importNode obj="doc" var="aNode" importedNode="docFrag" deep="true"/> |
| <childNodes obj="aNode" var="children"/> |
| <assertSize collection="children" size="1" id="throw_Size"/> |
| <firstChild interface="Node" obj="aNode" var="child"/> |
| <nodeValue obj="child" var="childValue"/> |
| <assertEquals actual="childValue" expected='"descendant1"' id="descendant1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode05.xml.unknown |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode05"> |
| <metadata> |
| <title>importNode05</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Element. |
| Retrieve element "emp:address" from staffNS.xml document. |
| Invoke method importNode(importedNode,deep) on this document |
| with importedNode being the element from above and deep is false. |
| Method should return an element node whose name matches "emp:address" |
| and whose children are not imported. The returned node should |
| belong to this document whose systemId is "staff.dtd" |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="aNode" type="Node"/> |
| <var name="hasChild" type="boolean"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <var name="name" type="DOMString"/> |
| <var name="addresses" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName var="addresses" obj="aNewDoc" interface="Document" tagname='"emp:address"'/> |
| <item var="element" obj="addresses" interface="NodeList" index="0"/> |
| <assertNotNull actual="element" id="empAddressNotNull"/> |
| <importNode obj="doc" var="aNode" importedNode="element" deep="false"/> |
| <hasChildNodes obj="aNode" var="hasChild"/> |
| <assertFalse actual="hasChild" id="hasChild"/> |
| <ownerDocument obj="aNode" var="ownerDocument"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="dtdSystemId"/> |
| <nodeName obj="aNode" var="name"/> |
| <assertEquals actual="name" expected='"emp:address"' id="nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode06.xml.unknown |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode06"> |
| <metadata> |
| <title>importNode06</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Element. |
| Retrieve element "emp:address" from staffNS.xml document. |
| Invoke method importNode(importedNode,deep) on this document |
| with importedNode being the element from above and deep is true. |
| Method should return an element node whose name matches "emp:address" and |
| whose descendant is imported. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="aNode" type="Node"/> |
| <var name="hasChild" type="boolean"/> |
| <var name="name" type="DOMString"/> |
| <var name="child" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <var name="addresses" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName var="addresses" obj="aNewDoc" interface="Document" tagname='"emp:address"'/> |
| <item var="element" obj="addresses" interface="NodeList" index="0"/> |
| <assertNotNull actual="element" id="empAddressNotNull"/> |
| <importNode obj="doc" var="aNode" importedNode="element" deep="true"/> |
| <hasChildNodes obj="aNode" var="hasChild"/> |
| <assertTrue actual="hasChild" id="throw_True"/> |
| <nodeName obj="aNode" var="name"/> |
| <assertEquals actual="name" expected='"emp:address"' id="nodeName" ignoreCase="false"/> |
| <firstChild interface="Node" obj="aNode" var="child"/> |
| <nodeValue obj="child" var="value"/> |
| <assertEquals actual="value" expected='"27 South Road. Dallas, texas 98556"' id="nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode07.xml.unknown |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode07"> |
| <metadata> |
| <title>importNode07</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Element. |
| If this document defines default attributes for this element name (importedNode), |
| those default attributes are assigned. |
| Create an element whose name is "emp:employee" in a different document. |
| Invoke method importNode(importedNode,deep) on this document which |
| defines default attribute for the element name "emp:employee". |
| Method should return an the imported element with an assigned default attribute. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=238"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="aNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="name" type="DOMString"/> |
| <var name="attr" type="Node"/> |
| <var name="lname" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString" value='"http://www.nist.gov"'/> |
| <var name="qualifiedName" type="DOMString" value='"emp:employee"'/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staff" willBeModified="true"/> |
| <createElementNS obj="aNewDoc" var="element" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <importNode obj="doc" var="aNode" importedNode="element" deep="false"/> |
| <attributes obj="aNode" var="attributes"/> |
| <assertSize collection="attributes" size="1" id="throw_Size"/> |
| <nodeName obj="aNode" var="name"/> |
| <assertEquals actual="name" expected='"emp:employee"' ignoreCase="false" id="nodeName"/> |
| <item interface="NamedNodeMap" obj="attributes" var="attr" index="0"/> |
| <localName obj="attr" var="lname"/> |
| <assertEquals actual="lname" expected='"defaultAttr"' ignoreCase="false" id="lname"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode08.xml.unknown |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode08"> |
| <metadata> |
| <title>importNode08</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Document_Fragment. |
| Create a DocumentFragment in a different document. |
| Invoke method importNode(importedNode,deep) on this document |
| with importedNode being the newly created DocumentFragment. |
| Method should return an empty DocumentFragment that belongs |
| to this document whose systemId is "staff.dtd" |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-Core-DocType-systemId"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="aNode" type="Node"/> |
| <var name="hasChild" type="boolean"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <createDocumentFragment obj="aNewDoc" var="docFrag"/> |
| <importNode obj="doc" var="aNode" importedNode="docFrag" deep="false"/> |
| <hasChildNodes obj="aNode" var="hasChild"/> |
| <assertFalse actual="hasChild" id="hasChild"/> |
| <ownerDocument obj="aNode" var="ownerDocument"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="system"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode09.xml.unknown |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode09"> |
| <metadata> |
| <title>importNode09</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Entity. |
| Retrieve entity "ent6" from staffNS.xml document. |
| Invoke method importNode(importedNode,deep) on this document. |
| Method should return a node of type Entity whose publicId, systemId and |
| notationName attributes are copied. |
| The returned node should belong to this document whose systemId is "staff.dtd" |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="doc1Type" type="DocumentType"/> |
| <var name="entityList" type="NamedNodeMap"/> |
| <var name="entity2" type="Entity"/> |
| <var name="entity1" type="Entity"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <var name="entityName" type="DOMString"/> |
| <var name="publicVal" type="DOMString"/> |
| <var name="notationName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <doctype obj="aNewDoc" var="docType"/> |
| <entities obj="docType" var="entityList"/> |
| <assertNotNull actual="entityList" id="entitiesNotNull"/> |
| <getNamedItem obj="entityList" var="entity2" name='"ent6"'/> |
| <importNode obj="doc" var="entity1" importedNode="entity2" deep="false"/> |
| <ownerDocument obj="entity1" var="ownerDocument"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="dtdSystemId"/> |
| <nodeName obj="entity1" var="entityName"/> |
| <assertEquals actual="entityName" expected='"ent6"' ignoreCase="false" id="entityName"/> |
| <publicId interface="Entity" obj="entity1" var="publicVal"/> |
| <assertEquals actual="publicVal" expected='"uri"' ignoreCase="false" id="entityPublicId"/> |
| <systemId interface="Entity" obj="entity1" var="system"/> |
| <assertURIEquals actual="system" file='"file"' id="entitySystemId"/> |
| <notationName obj="entity1" var="notationName"/> |
| <assertEquals actual="notationName" expected='"notation2"' ignoreCase="false" id="notationName"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode10.xml.unknown |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode10"> |
| <metadata> |
| <title>importNode10</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Entity_Reference. |
| Only the EntityReference is copied, regardless of deep's value. |
| Create an entity reference whose name is "entRef1" in a different document. |
| Give it value "entRef1Value". |
| Invoke method importNode(importedNode,deep) on this document with importedNode |
| being "entRef1". |
| Method should return a node of type Entity_Reference (whose value is null) that |
| belongs to this document whose systemId is "staff.dtd". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="aNode" type="Node"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <var name="name" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <createEntityReference obj="aNewDoc" var="entRef" name='"entRef1"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <nodeValue obj="entRef" value='"entRef1Value"'/> |
| <importNode obj="doc" var="aNode" importedNode="entRef" deep="false"/> |
| <ownerDocument obj="aNode" var="ownerDocument"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="systemId"/> |
| <nodeName obj="aNode" var="name"/> |
| <assertEquals actual="name" expected='"entRef1"' id="nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode11.xml.unknown |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode11"> |
| <metadata> |
| <title>importNode11</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Entity_Reference. |
| Only the EntityReference is copied, regardless of deep's value. |
| If the Document provides a definition for the entity name, its value is assigned. |
| Create an entity reference whose name is "ent3" in a different document. |
| Invoke method importNode(importedNode,deep) on this document with importedNode |
| being "ent3". |
| Method should return a node of type Entity_Reference whose first child's value is "Texas" as defined |
| in this document. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="aNode" type="Node"/> |
| <var name="name" type="DOMString"/> |
| <var name="child" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <load var="aNewDoc" href="staff" willBeModified="true"/> |
| <createEntityReference obj="aNewDoc" var="entRef" name='"ent3"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <importNode obj="doc" var="aNode" importedNode="entRef" deep="true"/> |
| <nodeName obj="aNode" var="name"/> |
| <assertEquals actual="name" id="entityName" expected='"ent3"' ignoreCase="false"/> |
| <firstChild interface="Node" obj="aNode" var="child"/> |
| <assertNotNull id="child" actual="child"/> |
| <nodeValue obj="child" var="childValue"/> |
| <assertEquals actual="childValue" id="childValue" expected='"Texas"' ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode12.xml.unknown |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode12"> |
| <metadata> |
| <title>importNode12</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Entity. |
| Retrieve entity "ent4" from staffNS.xml document. |
| Invoke method importNode(importedNode,deep) on this document with deep as false. |
| Method should return a node of type Entity whose descendant is copied. |
| The returned node should belong to this document whose systemId is "staffNS.dtd" |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="doc1Type" type="DocumentType"/> |
| <var name="entityList" type="NamedNodeMap"/> |
| <var name="entity2" type="Entity"/> |
| <var name="entity1" type="Entity"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <var name="entityName" type="DOMString"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <doctype obj="aNewDoc" var="doc1Type"/> |
| <entities obj="doc1Type" var="entityList"/> |
| <assertNotNull actual="entityList" id="entitiesNotNull"/> |
| <getNamedItem obj="entityList" var="entity2" name='"ent4"'/> |
| <importNode obj="doc" var="entity1" importedNode="entity2" deep="true"/> |
| <ownerDocument obj="entity1" var="ownerDocument"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="systemId"/> |
| <nodeName obj="entity1" var="entityName"/> |
| <assertEquals actual="entityName" expected='"ent4"' id="entityName" ignoreCase="false"/> |
| <firstChild interface="Node" obj="entity1" var="child"/> |
| <assertNotNull actual="child" id="notnull"/> |
| <nodeName obj="child" var="childName"/> |
| <assertEquals actual="childName" expected='"entElement1"' id="childName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode13.xml.unknown |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode13"> |
| <metadata> |
| <title>importNode13</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Notation. |
| Retrieve notation named "notation1" from document staffNS.xml. |
| Invoke method importNode(importedNode,deep) where importedNode |
| contains the retrieved notation and deep is false. Method should |
| return a node of type notation whose name is "notation1". |
| The returned node should belong to this document whose systemId is "staff.dtd" |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="doc1Type" type="DocumentType"/> |
| <var name="notationList" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="aNode" type="Notation"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <var name="publicVal" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <doctype obj="aNewDoc" var="doc1Type"/> |
| <notations obj="doc1Type" var="notationList"/> |
| <assertNotNull actual="notationList" id="notationsNotNull"/> |
| <getNamedItem obj="notationList" var="notation" name='"notation1"'/> |
| <importNode obj="doc" var="aNode" importedNode="notation" deep="false"/> |
| <ownerDocument obj="aNode" var="ownerDocument"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="systemId"/> |
| <publicId interface="Notation" obj="aNode" var="publicVal"/> |
| <assertEquals actual="publicVal" expected='"notation1File"' id="publicId" ignoreCase="false"/> |
| <systemId interface="Notation" obj="aNode" var="system"/> |
| <assertNull actual="system" id="notationSystemId"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode14.xml.unknown |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode14"> |
| <metadata> |
| <title>importNode14</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Processing Instruction. |
| Create a processing instruction with target as "target1" and data as "data1" |
| in a different document. Invoke method importNode(importedNode,deep) on this document. |
| Method should return a processing instruction whose target and data match the given |
| parameters. The returned PI should belong to this document whose systemId is "staff.dtd". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="aNode" type="ProcessingInstruction"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <var name="target" type="DOMString"/> |
| <var name="data" type="DOMString"/> |
| <var name="result" type="List"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <createProcessingInstruction obj="aNewDoc" var="pi" target='"target1"' data='"data1"'/> |
| <importNode obj="doc" var="aNode" importedNode="pi" deep="false"/> |
| <ownerDocument obj="aNode" var="ownerDocument"/> |
| <assertNotNull actual="ownerDocument" id="ownerDocumentNotNull"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="systemId"/> |
| <target interface="ProcessingInstruction" obj="aNode" var="target"/> |
| <assertEquals actual="target" expected='"target1"' id="piTarget" ignoreCase="false"/> |
| <data interface="ProcessingInstruction" obj="aNode" var="data"/> |
| <assertEquals actual="data" expected='"data1"' id="piData" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode15.xml.unknown |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode15"> |
| <metadata> |
| <title>importNode15</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should import the given importedNode into that Document. |
| The importedNode is of type Text. |
| Create a text node with value being the string "this is text data" in |
| a different document. Invoke method importNode(importedNode,deep) on |
| this document. Method should return a text node whose value matches |
| the above string. The returned node should belong to this document |
| whose systemId is "staff.dtd" |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="aNewDoc" type="Document"/> |
| <var name="text" type="Text"/> |
| <var name="aNode" type="Node"/> |
| <var name="ownerDocument" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="system" type="DOMString"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="aNewDoc" href="staffNS" willBeModified="true"/> |
| <createTextNode obj="aNewDoc" var="text" data='"this is text data"'/> |
| <importNode obj="doc" var="aNode" importedNode="text" deep="false"/> |
| <ownerDocument obj="aNode" var="ownerDocument"/> |
| <assertNotNull actual="ownerDocument" id="ownerDocumentNotNull"/> |
| <doctype obj="ownerDocument" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="system"/> |
| <assertURIEquals actual="system" file='"staffNS.dtd"' id="systemId"/> |
| <nodeValue obj="aNode" var="value"/> |
| <assertEquals actual="value" expected='"this is text data"' id="nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode16.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode16"> |
| <metadata> |
| <title>importNode16</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should raise NOT_SUPPORTED_ERR DOMException if |
| the type of node being imported is DocumentType. |
| Retrieve document staff.xml and get its type. |
| Invoke method importNode(importedNode,deep) where importedNode |
| contains the document type of the staff.xml. |
| Method should raise NOT_SUPPORT_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NOT_SUPPORTED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('Core-Document-importNode')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_SUPPORTED_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="anotherDoc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="node" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="anotherDoc" href="staffNS" willBeModified="true"/> |
| <doctype obj="anotherDoc" var="docType"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <importNode obj="doc" var="node" importedNode="docType" deep="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/importNode17.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="importNode17"> |
| <metadata> |
| <title>importNode17</title> |
| <creator>NIST</creator> |
| <description> |
| The "importNode(importedNode,deep)" method for a |
| Document should raise NOT_SUPPORTED_ERR DOMException if |
| the type of node being imported is Document. |
| Retrieve staff.xml document. |
| Invoke method importNode(importedNode,deep) where importedNode |
| contains staff.xml and deep is true. |
| Method should raise NOT_SUPPORTED_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NOT_SUPPORTED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Core-Document-importNode"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('Core-Document-importNode')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_SUPPORTED_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="anotherDoc" type="Document"/> |
| <var name="node" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="anotherDoc" href="staffNS" willBeModified="true"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <importNode obj="doc" var="node" importedNode="anotherDoc" deep="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/internalSubset01.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="internalSubset01"> |
| <metadata> |
| <title>internalSubset01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getInternalSubset()" method returns |
| the internal subset as a string or null if there is none. |
| This does not contain the delimiting brackets. |
| Retrieve the documenttype. |
| Apply the "getInternalSubset()" method. Null is returned since there |
| is not an internal subset. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-07-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-Core-DocType-internalSubset"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="internal" type="DOMString"/> |
| <load var="doc" href="staff2" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <internalSubset obj="docType" var="internal"/> |
| <assertNull actual="internal" id="internalSubsetNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported01.xml.unknown |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported01"> |
| <metadata> |
| <title>isSupported01</title> |
| <creator>NIST</creator> |
| <description> |
| The "feature" parameter in the |
| isSupported(feature,version)" method is the name |
| of the feature and the version is the version number of the |
| feature to test. XXX is NOT a legal value for the feature parameter. |
| The method should return "false" since XXX is not a valid feature. |
| Retrieve the root node of the DOM document by invoking |
| the "getDocumentElement()" method. This should create a |
| node object on which the "isSupported(feature,version)" |
| method is invoked with "feature" equal to "XXX" and version to "1.0". |
| The method should return a boolean "false" since XXX is not a valid feature. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature=""XXX"" version=""1.0"" var="state"/> |
| <assertFalse actual="state" id="throw_False"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported02.xml.unknown |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported02"> |
| <metadata> |
| <title>isSupported02</title> |
| <creator>NIST</creator> |
| <description> |
| The "feature" parameter in the |
| isSupported(feature,version)" method is the name |
| of the feature and the version is the version number of the |
| feature to test. XML is a legal value for the feature parameter. |
| The method should return "false" since 9.0 is not a valid version. |
| Retrieve the root node of the DOM document by invoking |
| the "getDocumentElement()" method. This should create a |
| node object on which the "isSupported(feature,version)" |
| method is invoked with "feature" equal to "XML" and version to "9.0". |
| The method should return a boolean "false" since 9.0 is not a valid version. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature=""XML"" version=""9.0"" var="state"/> |
| <assertFalse actual="state" id="throw_False"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported04.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported04"> |
| <metadata> |
| <title>isSupported04</title> |
| <creator>NIST</creator> |
| <description> |
| The "feature" parameter in the |
| isSupported(feature,version)" method is the name |
| of the feature and the version is the version number of the |
| feature to test. XML is a legal value for the feature parameter |
| (Test for xml, lower case). |
| Legal values for the version parameter are 1.0 and 2.0 |
| (Test for 1.0). |
| Retrieve the root node of the DOM document by invoking |
| the "getDocumentElement()" method. This should create a |
| node object on which the "isSupported(feature,version)" |
| method is invoked with "feature" equal to "xml" and the version equal to 1.0. |
| The method should return a boolean "true". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature=""xml"" version=""1.0"" var="state"/> |
| <assertTrue actual="state" id="throw_True"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported05.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported05"> |
| <metadata> |
| <title>isSupported05</title> |
| <creator>NIST</creator> |
| <description> |
| The "feature" parameter in the |
| isSupported(feature,version)" method is the name |
| of the feature and the version is the version number of the |
| feature to test. Core is a legal value for the feature parameter |
| (Test for core, lower case). |
| Legal values for the version parameter are 1.0 and 2.0 |
| (Test for 2.0). |
| Retrieve the root node of the DOM document by invoking |
| the "getDocumentElement()" method. This should create a |
| node object on which the "isSupported(feature,version)" |
| method is invoked with "feature" equal to "core" and the version equal to 2.0. |
| The method should return a boolean "true". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature=""core"" version=""2.0"" var="state"/> |
| <assertTrue actual="state" id="throw_True"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported06.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported06"> |
| <metadata> |
| <title>isSupported06</title> |
| <creator>NIST</creator> |
| <description> |
| The "feature" parameter in the |
| isSupported(feature,version)" method is the name |
| of the feature and the version is the version number of the |
| feature to test. XML is a legal value for the feature parameter |
| (Test for xml, lower case). |
| Legal values for the version parameter are 1.0 and 2.0 |
| (Test for 2.0). |
| Retrieve the root node of the DOM document by invoking |
| the "getDocumentElement()" method. This should create a |
| node object on which the "isSupported(feature,version)" |
| method is invoked with "feature" equal to "xml" and the version equal to 2.0. |
| The method should return a boolean "true". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature=""xml"" version=""2.0"" var="state"/> |
| <assertTrue actual="state" id="throw_True"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported07.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported07"> |
| <metadata> |
| <title>isSupported07</title> |
| <creator>NIST</creator> |
| <description> |
| The "feature" parameter in the |
| isSupported(feature,version)" method is the name |
| of the feature and the version is the version number of the |
| feature to test. XML is a legal value for the feature parameter |
| (Test for XML). |
| If the version is not specified, supporting any version of the |
| method to return true. |
| Retrieve the root node of the DOM document by invoking |
| the "getDocumentElement()" method. This should create a |
| node object on which the "isSupported(feature,version)" |
| method is invoked with "feature" equal to "XML" and the version equal blank. |
| The method should return a boolean "true". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature=""XML"" version="""" var="state"/> |
| <assertTrue actual="state" id="throw_True"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported09.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported09"> |
| <metadata> |
| <title>isSupported09</title> |
| <creator>NIST</creator> |
| <description> |
| The "feature" parameter in the |
| isSupported(feature,version)" method is the name |
| of the feature and the version is the version number of the |
| feature to test. XML is a legal value for the feature parameter |
| (Test for XML, upper case). |
| Legal values for the version parameter are 1.0 and 2.0 |
| (Test for 1.0). |
| Retrieve the root node of the DOM document by invoking |
| the "getDocumentElement()" method. This should create a |
| node object on which the "isSupported(feature,version)" |
| method is invoked with "feature" equal to "XML" and the version equal to 1.0. |
| The method should return a boolean "true". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature=""XML"" version=""1.0"" var="state"/> |
| <assertTrue actual="state" id="throw_True"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported10.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported10"> |
| <metadata> |
| <title>isSupported10</title> |
| <creator>NIST</creator> |
| <description> |
| The "feature" parameter in the |
| isSupported(feature,version)" method is the name |
| of the feature and the version is the version number of the |
| feature to test. CORE is a legal value for the feature parameter |
| (Test for CORE, upper case). |
| Legal values for the version parameter are 1.0 and 2.0 |
| (Test for 2.0). |
| Retrieve the root node of the DOM document by invoking |
| the "getDocumentElement()" method. This should create a |
| node object on which the "isSupported(feature,version)" |
| method is invoked with "feature" equal to "CORE" and the version equal to 2.0. |
| The method should return a boolean "true". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature=""CORE"" version=""2.0"" var="state"/> |
| <assertTrue actual="state" id="throw_True"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported11.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported11"> |
| <metadata> |
| <title>isSupported11</title> |
| <creator>NIST</creator> |
| <description> |
| The "feature" parameter in the |
| isSupported(feature,version)" method is the name |
| of the feature and the version is the version number of the |
| feature to test. XML is a legal value for the feature parameter |
| (Test for XML, upper case). |
| Legal values for the version parameter are 1.0 and 2.0 |
| (Test for 2.0). |
| Retrieve the root node of the DOM document by invoking |
| the "getDocumentElement()" method. This should create a |
| node object on which the "isSupported(feature,version)" |
| method is invoked with "feature" equal to "XML" and the version equal to 2.0. |
| The method should return a boolean "true". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature=""XML"" version=""2.0"" var="state"/> |
| <assertTrue actual="state" id="throw_True"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported12.xml.unknown |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported12"> |
| <metadata> |
| <title>isSupported12</title> |
| <creator>NIST</creator> |
| <description> |
| The "feature" parameter in the |
| isSupported(feature,version)" method is the name |
| of the feature and the version is the version number of the |
| feature to test. CORE is a legal value for the feature parameter |
| (Test for CORE, upper case). |
| Legal values for the version parameter are 1.0 and 2.0 |
| (Test for 1.0). |
| Retrieve the root node of the DOM document by invoking |
| the "getDocumentElement()" method. This should create a |
| node object on which the "isSupported(feature,version)" |
| method is invoked with "feature" equal to "CORE" and the version equal to 1.0. |
| The method should return a boolean "true". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="features" type="List"> |
| <member>"Core"</member> |
| <member>"XML"</member> |
| <member>"HTML"</member> |
| <member>"Views"</member> |
| <member>"StyleSheets"</member> |
| <member>"CSS"</member> |
| <member>"CSS2"</member> |
| <member>"Events"</member> |
| <member>"UIEvents"</member> |
| <member>"MouseEvents"</member> |
| <member>"MutationEvents"</member> |
| <member>"HTMLEvents"</member> |
| <member>"Range"</member> |
| <member>"Traversal"</member> |
| <member>"bogus.bogus.bogus"</member> |
| </var> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="featureElement" type="DOMString"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <!--- All XML implementations must support core --> |
| <isSupported obj="rootNode" feature='"Core"' version='"2.0"' var="state"/> |
| <assertTrue actual="state" id="Core2"/> |
| <for-each collection="features" member="featureElement"> |
| <isSupported obj="rootNode" feature="featureElement" version='"1.0"' var="state"/> |
| </for-each> |
| <for-each collection="features" member="featureElement"> |
| <isSupported obj="rootNode" feature="featureElement" version='"2.0"' var="state"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported13.xml.unknown |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported13"> |
| <metadata> |
| <title>isSupported13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Calls isSupported("Core","") should return true for all implementations (by extension of core-14). |
| </description> |
| <date qualifier="created">2001-11-27</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/2000/11/DOM-Level-2-errata#core-14"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature='"Core"' version='""' var="state"/> |
| <assertTrue actual="state" id="Core"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/isSupported14.xml.unknown |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="isSupported14"> |
| <metadata> |
| <title>isSupported14</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Calls isSupported("Core",null) should return true for all implementations (by extension of core-14). |
| </description> |
| <date qualifier="created">2001-11-27</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/2000/11/DOM-Level-2-errata#core-14"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="rootNode" type="Node"/> |
| <var name="state" type="boolean"/> |
| <var name="nullString" type="DOMString" isNull="true"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="rootNode"/> |
| <isSupported obj="rootNode" feature='"Core"' version="nullString" var="state"/> |
| <assertTrue actual="state" id="Core"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/localName01.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="localName01"> |
| <metadata> |
| <title>localName01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getLocalName()" method for a Node |
| returns the local part of the qualified name of this node, |
| and for nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE |
| and nodes created with a DOM Level 1 method, this is null. |
| Retrieve the first emp:address node and get the attributes of this node." |
| Then apply the getLocalName() method to the emp:domestic attribute. |
| The method should return "domestic". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSLocalN"/> |
| </metadata> |
| <!-- this test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="localName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"emp:address"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <getAttributeNode obj="testAddr" name='"emp:domestic"' var="addrAttr"/> |
| <localName obj="addrAttr" var="localName"/> |
| <assertEquals actual="localName" expected='"domestic"' id="localName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/localName02.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="localName02"> |
| <metadata> |
| <title>localName02</title> |
| <creator>NIST</creator> |
| <description> |
| The "getLocalName()" method for a Node |
| returns the local part of the qualified name of this node, |
| and for nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE |
| and nodes created with a DOM Level 1 method, this is null. |
| Create an new Element with the createElement() method. |
| Invoke the "getLocalName()" method on the newly created element |
| node will cause "null" to be returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSLocalN"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="createdNode" type="Node"/> |
| <var name="localName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createElement obj="doc" tagName=""test:employee"" var="createdNode"/> |
| <localName obj="createdNode" var="localName"/> |
| <assertNull actual="localName" id="localNameNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/localName03.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="localName03"> |
| <metadata> |
| <title>localName03</title> |
| <creator>NIST</creator> |
| <description> |
| The "getLocalName()" method for a Node |
| returns the local part of the qualified name of this node, |
| and for nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE |
| and nodes created with a DOM Level 1 method, this is null. |
| Retrieve the first employeeId node and get the first child of this node. |
| Since the first child is Text node invoking the "getLocalName()" |
| method will cause "null" to be returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSLocalN"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="localName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employeeId"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <firstChild interface="Node" obj="testEmployee" var="textNode"/> |
| <localName obj="textNode" var="localName"/> |
| <assertNull actual="localName" id="textNodeLocalName"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/localName04.xml.unknown |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="localName04"> |
| <metadata> |
| <title>localName04</title> |
| <creator>NIST</creator> |
| <description> |
| The "getLocalName()" method for a Node |
| returns the local part of the qualified name of this node, |
| and for nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE |
| and nodes created with a DOM Level 1 method, this is null. |
| Retrieve the first employee node and invoke the "getLocalName()" |
| method. The method should return "employee". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSLocalN"/> |
| </metadata> |
| <!-- this test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="employeeLocalName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <localName obj="testEmployee" var="employeeLocalName"/> |
| <assertEquals actual="employeeLocalName" expected='"employee"' id="lname" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/metadata.xml.unknown |
|---|
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| + |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapgetnameditemns01.xml.unknown |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapgetnameditemns01"> |
| <metadata> |
| <title>namednodemapgetnameditemns01</title> |
| <creator>IBM</creator> |
| <description> |
| Using the method getNamedItemNS, retreive the entity "ent1" and notation "notation1" |
| from a NamedNodeMap of this DocumentTypes entities and notations. |
| Both should be null since entities and notations are not namespaced. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getNamedItemNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=407"/> |
| <subject resource="http://lists.w3.org/Archives/Member/w3c-dom-ig/2003Nov/0016.html"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="notation" type="Notation"/> |
| <var name="entityName" type="DOMString"/> |
| <var name="notationName" type="DOMString"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entities" obj="docType"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <notations var="notations" obj="docType"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItemNS var="entity" obj="entities" namespaceURI="nullNS" localName='"ent1"'/> |
| <assertNull actual="entity" id="entityNull"/> |
| <getNamedItemNS var="notation" obj="notations" namespaceURI="nullNS" localName='"notation1"'/> |
| <assertNull actual="notation" id="notationNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapgetnameditemns02.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapgetnameditemns02"> |
| <metadata> |
| <title>namednodemapgetnameditemns02</title> |
| <creator>IBM</creator> |
| <description> |
| The method getNamedItemNS retrieves a node specified by local name and namespace URI. |
| Using the method getNamedItemNS, retreive an attribute node having namespaceURI=http://www.nist.gov |
| and localName=domestic, from a NamedNodeMap of attribute nodes, for the second element |
| whose namespaceURI=http://www.nist.gov and localName=address. Verify if the attr node |
| has been retreived successfully by checking its nodeName atttribute. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Node"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"http://www.nist.gov"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.nist.gov"' localName='"domestic"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <assertEquals actual="attrName" expected='"emp:domestic"' id="namednodemapgetnameditemns02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapgetnameditemns03.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapgetnameditemns03"> |
| <metadata> |
| <title>namednodemapgetnameditemns03</title> |
| <creator>IBM</creator> |
| <description> |
| The method getNamedItemNS retrieves a node specified by local name and namespace URI. |
| Create a new Element node and add 2 new attribute nodes having the same local name but different |
| namespace names and namespace prefixes to it. Using the getNamedItemNS retreive the second attribute node. |
| Verify if the attr node has been retreived successfully by checking its nodeName atttribute. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Node"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttr1" type="Attr"/> |
| <var name="newAttr2" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"root"'/> |
| <createAttributeNS var="newAttr1" obj="doc" namespaceURI='"http://www.w3.org/DOM/L1"' qualifiedName='"L1:att"'/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="newAttr1"/> |
| <createAttributeNS var="newAttr2" obj="doc" namespaceURI='"http://www.w3.org/DOM/L2"' qualifiedName='"L2:att"'/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="newAttr2"/> |
| <attributes var="attributes" obj="element"/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.w3.org/DOM/L2"' localName='"att"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <assertEquals actual="attrName" expected='"L2:att"' id="namednodemapgetnameditemns03" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapgetnameditemns04.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapgetnameditemns04"> |
| <metadata> |
| <title>namednodemapgetnameditemns04</title> |
| <creator>IBM</creator> |
| <description> |
| The method getNamedItemNS retrieves a node specified by local name and namespace URI. |
| Retreive the second address element node having localName=adrress. |
| Create a new attribute node having the same name as an existing node but different namespaceURI |
| and add it to this element. Using the getNamedItemNS retreive the newly created attribute |
| node from a nodemap of attributes of the retreive element node. |
| Verify if the attr node has been retreived successfully by checking its nodeName atttribute. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttr1" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <createAttributeNS var="newAttr1" obj="doc" namespaceURI='"http://www.w3.org/DOM/L1"' qualifiedName='"street"'/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="newAttr1"/> |
| <attributes var="attributes" obj="element"/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.w3.org/DOM/L1"' localName='"street"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <assertEquals actual="attrName" expected='"street"' id="namednodemapgetnameditemns04" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapgetnameditemns05.xml.unknown |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapgetnameditemns05"> |
| <metadata> |
| <title>namednodemapgetnameditemns05</title> |
| <creator>IBM</creator> |
| <description> |
| The method getNamedItemNS retrieves a node specified by local name and namespace URI. |
| Retreieve the second address element and its attribute into a named node map. |
| Try retreiving the street attribute from the namednodemap using the |
| default namespace uri and the street attribute name. Since the default |
| namespace doesnot apply to attributes this should return null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Node"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI='"*"' localName='"street"'/> |
| <assertNull actual="attribute" id="namednodemapgetnameditemns05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapgetnameditemns06.xml.unknown |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapgetnameditemns06"> |
| <metadata> |
| <title>namednodemapgetnameditemns06</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive the second address element node having localName=adrress. Retreive the attributes |
| of this element into 2 nodemaps. Create a new attribute node and add it to this element. |
| Since NamedNodeMaps are live each one should get updated, using the getNamedItemNS retreive |
| the newly created attribute from each node map. |
| Verify if the attr node has been retreived successfully by checking its nodeName atttribute. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributesMap1" type="NamedNodeMap"/> |
| <var name="attributesMap2" type="NamedNodeMap"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttr1" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributesMap1" obj="element"/> |
| <attributes var="attributesMap2" obj="element"/> |
| <createAttributeNS var="newAttr1" obj="doc" namespaceURI='"http://www.w3.org/DOM/L1"' qualifiedName='"street"'/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="newAttr1"/> |
| <getNamedItemNS var="attribute" obj="attributesMap1" namespaceURI='"http://www.w3.org/DOM/L1"' localName='"street"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <assertEquals actual="attrName" expected='"street"' id="namednodemapgetnameditemnsMap106" ignoreCase="false"/> |
| <getNamedItemNS var="attribute" obj="attributesMap2" namespaceURI='"http://www.w3.org/DOM/L1"' localName='"street"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <assertEquals actual="attrName" expected='"street"' id="namednodemapgetnameditemnsMap206" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapremovenameditemns01.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapremovenameditemns01"> |
| <metadata> |
| <title>namednodemapremovenameditemns01</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeNamedItemNS removes a node specified by local name and namespace |
| Retreive an attribute node and then remove from the NamedNodeMap. Verify if the attribute |
| node was actually remove from the node map. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-D58B193"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Node"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"http://www.nist.gov"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <removeNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.nist.gov"' localName='"domestic"'/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.nist.gov"' localName='"domestic"'/> |
| <assertNull actual="attribute" id="namednodemapremovenameditemns01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapremovenameditemns02.xml.unknown |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapremovenameditemns02"> |
| <metadata> |
| <title>namednodemapremovenameditemns02</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeNamedItemNS removes a node specified by local name and namespace |
| A removed attribute may be known to have a default value when this map contains the |
| attributes attached to an element, as returned by the attributes attribute of the Node |
| interface. If so, an attribute immediately appears containing the default value as well |
| as the corresponding namespace URI, local name, and prefix when applicable. |
| Retreive a default attribute node. Remove it from the NodeMap. Check if a new one immediately |
| appears containing the default value. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-D58B193"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Node"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" localName='"employee"' namespaceURI='"http://www.nist.gov"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <removeNamedItemNS var="attribute" obj="attributes" namespaceURI="nullNS" localName='"defaultAttr"'/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI="nullNS" localName='"defaultAttr"'/> |
| <nodeValue var="attrValue" obj="attribute"/> |
| <assertNotNull actual="attribute" id="namednodemapremovenameditemns02"/> |
| <assertEquals actual="attrValue" expected='"defaultVal"' id="namednodemapremovenameditemns02_attrValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapremovenameditemns03.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapremovenameditemns03"> |
| <metadata> |
| <title>namednodemapremovenameditemns03</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeNamedItemNS removes a node specified by local name and namespace |
| Create a new element node and add 2 new attribute nodes to it that have the same localName |
| but different namespaceURI's. Remove the first attribute node from the namedNodeMap of the |
| new element node and check to see that the second attribute still exists. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-D58B193"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Node"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="attribute1" type="Attr"/> |
| <var name="attribute2" type="Attr"/> |
| <var name="nodeName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"root"'/> |
| <createAttributeNS var="attribute1" obj="doc" namespaceURI='"http://www.w3.org/DOM/L1"' qualifiedName='"L1:att"'/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="attribute1"/> |
| <createAttributeNS var="attribute2" obj="doc" namespaceURI='"http://www.w3.org/DOM/L2"' qualifiedName='"L2:att"'/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="attribute2"/> |
| <attributes var="attributes" obj="element"/> |
| <removeNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.w3.org/DOM/L1"' localName='"att"'/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.w3.org/DOM/L2"' localName='"att"'/> |
| <nodeName var="nodeName" obj="attribute"/> |
| <assertEquals actual="nodeName" expected='"L2:att"' id="namednodemapremovenameditemns02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapremovenameditemns04.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapremovenameditemns04"> |
| <metadata> |
| <title>namednodemapremovenameditemns04</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeNamedItemNS removes a node specified by local name and namespace |
| Attempt to remove the xmlns and dmstc attributes of the first element node with the localName |
| employee. Verify if the 2 attributes were successfully removed. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-D58B193"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Node"/> |
| <var name="attribute" type="Attr"/> |
| <var name="attributeRemoved" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"employee"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <removeNamedItemNS var="attributeRemoved" obj="attributes" namespaceURI='"http://www.w3.org/2000/xmlns/"' localName='"xmlns"'/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.w3.org/2000/xmlns/"' localName='"xmlns"'/> |
| <assertNull actual="attribute" id="namednodemapremovenameditemns04_1"/> |
| <removeNamedItemNS var="attributeRemoved" obj="attributes" namespaceURI='"http://www.w3.org/2000/xmlns/"' localName='"dmstc"'/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.w3.org/2000/xmlns/"' localName='"dmstc"'/> |
| <assertNull actual="attribute" id="namednodemapremovenameditemns04_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapremovenameditemns05.xml.unknown |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapremovenameditemns05"> |
| <metadata> |
| <title>namednodemapremovenameditemns05</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive an entity and notation node and remove the first notation from the |
| entity node map and first entity node from the notation map. Since both these |
| maps are readonly, a NO_MODIFICATION_ALLOWED_ERR should be raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=407"/> |
| <subject resource="http://lists.w3.org/Archives/Member/w3c-dom-ig/2003Nov/0016.html"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="removedNode" type="Node"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entities" obj="docType"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <notations var="notations" obj="docType"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <try> |
| <removeNamedItemNS var="removedNode" obj="entities" namespaceURI="nullNS" localName='"ent1"'/> |
| <fail id="entity_throw_DOMException"/> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"/> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| </catch> |
| </try> |
| <try> |
| <removeNamedItemNS var="removedNode" obj="notations" namespaceURI="nullNS" localName='"notation1"'/> |
| <fail id="notation_throw_DOMException"/> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"/> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapremovenameditemns06.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapremovenameditemns06"> |
| <metadata> |
| <title>namednodemapremovenameditemns06</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeNamedItemNS removes a node using its namespaceURI and localName and |
| raises a NOT_FOUND_ERR if there is no node with the specified namespaceURI and |
| localName in this map |
| Retreive an attribute node into a namednodemap. While removing it from the map specify |
| an incorrect namespaceURI. This should raise a NOT_FOUND_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-D58B193"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Node"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" localName='"employee"' namespaceURI='"http://www.nist.gov"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.Nist.gov"' localName='"domestic"'/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapremovenameditemns07.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapremovenameditemns07"> |
| <metadata> |
| <title>namednodemapremovenameditemns07</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeNamedItemNS removes a node using its namespaceURI and localName and |
| raises a NOT_FOUND_ERR if there is no node with the specified namespaceURI and |
| localName in this map |
| Retreive an attribute node from a namednodemap. While removing it from the map specify |
| an incorrect localName. This should raise a NOT_FOUND_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-D58B193"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Node"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" localName='"employee"' namespaceURI='"http://www.nist.gov"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.nist.gov"' localName='"domestic"'/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapremovenameditemns08.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapremovenameditemns08"> |
| <metadata> |
| <title>namednodemapremovenameditemns08</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeNamedItemNS removes a node using its namespaceURI and localName and |
| raises a NOT_FOUND_ERR if there is no node with the specified namespaceURI and |
| localName in this map |
| Retreive an attribute node from a namednodemap. Remove the attribute node from the document |
| object. Since NamedNodeMaps are live it should also automatically get removed from |
| the node map. And so if an attempt is made to remove it using removeAttributeNS, this should |
| raise a NOT_FOUND_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-D58B193"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" localName='"address"' namespaceURI='"http://www.nist.gov"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <removeAttributeNS obj="element" namespaceURI='"http://www.nist.gov"' localName='"domestic"'/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.nist.gov"' localName='"domestic"'/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapremovenameditemns09.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapremovenameditemns09"> |
| <metadata> |
| <title>namednodemapremovenameditemns09</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeNamedItemNS removes a node using its namespaceURI and localName and |
| raises a NOT_FOUND_ERR if there is no node with the specified namespaceURI and |
| localName in this map |
| Retreive an attribute node. Remove the attribute node from the node map. |
| Check the element object to ensure that the attribute node has been removed from it. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-D58B193"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="newAttributes" type="NamedNodeMap"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" localName='"address"' namespaceURI='"http://www.nist.gov"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <removeNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.nist.gov"' localName='"domestic"'/> |
| <attributes var="newAttributes" obj="element"/> |
| <getNamedItemNS var="attribute" obj="newAttributes" namespaceURI='"http://www.nist.gov"' localName='"domestic"'/> |
| <assertNull actual="attribute" id="namednodemapremovenameditemns09"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns01.xml.unknown |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns01"> |
| <metadata> |
| <title>namednodemapsetnameditemns01</title> |
| <creator>IBM</creator> |
| <description> |
| The method setNamedItemNS adds a node using its namespaceURI and localName. If a node with |
| that namespace URI and that local name is already present in this map, it is replaced |
| by the new one. |
| Retreive the first element whose localName is address and namespaceURI http://www.nist.gov", |
| and put its attributes into a named node map. Create a new attribute node and add it to this map. |
| Verify if the attr node was successfully added by checking the nodeName of the retreived atttribute. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-getNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Node"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="newAttr1" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"http://www.nist.gov"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <createAttributeNS var="newAttr1" obj="doc" namespaceURI='"http://www.w3.org/DOM/L1"' qualifiedName='"streets"'/> |
| <setAttributeNodeNS var="newAttribute" obj="element" newAttr="newAttr1"/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.w3.org/DOM/L1"' localName='"streets"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <assertEquals actual="attrName" expected='"streets"' id="namednodemapsetnameditemns01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns02.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns02"> |
| <metadata> |
| <title>namednodemapsetnameditemns02</title> |
| <creator>IBM</creator> |
| <description> |
| The method setNamedItemNS adds a node using its namespaceURI and localName. If a node with |
| that namespace URI and that local name is already present in this map, it is replaced |
| by the new one. |
| Create a new element and attribute Node and add the newly created attribute node to the elements |
| NamedNodeMap. Verify if the new attr node has been successfully added to the map by checking |
| the nodeName of the retreived atttribute from the list of attribute nodes in this map. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="attribute1" type="Attr"/> |
| <var name="newNode" type="Node"/> |
| <var name="attrName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"root"'/> |
| <createAttributeNS var="attribute1" obj="doc" namespaceURI='"http://www.w3.org/DOM/L1"' qualifiedName='"L1:att"'/> |
| <attributes var="attributes" obj="element"/> |
| <setNamedItemNS var="newNode" obj="attributes" arg="attribute1"/> |
| <getNamedItemNS var="attribute" obj="attributes" namespaceURI='"http://www.w3.org/DOM/L1"' localName='"att"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <assertEquals actual="attrName" expected='"L1:att"' id="namednodemapsetnameditemns02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns03.xml.unknown |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns03"> |
| <metadata> |
| <title>namednodemapsetnameditemns03</title> |
| <creator>IBM</creator> |
| <description> |
| The method setNamedItemNS adds a node using its namespaceURI and localName and |
| raises a WRONG_DOCUMENT_ERR if arg was created from a different document than the |
| one that created this map. |
| Retreieve the second element whose local name is address and its attribute into a named node map. |
| Do the same for another document and retreive its street attribute. Call the setNamedItemNS |
| using the first namedNodeMap and the retreive street attribute of the second. This should |
| raise a WRONG_DOCUMENT_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=408"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docAlt" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="attributesAlt" type="NamedNodeMap"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elementListAlt" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="elementAlt" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="newNode" type="Node"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <load var="docAlt" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementListAlt" obj="docAlt" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="elementAlt" obj="elementListAlt" index="1" interface="NodeList"/> |
| <attributes var="attributesAlt" obj="elementAlt"/> |
| <getNamedItemNS var="attr" obj="attributesAlt" namespaceURI="nullNS" localName='"street"'/> |
| <removeNamedItemNS var="newNode" obj="attributesAlt" namespaceURI="nullNS" localName='"street"'/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <setNamedItemNS var="newNode" obj="attributes" arg="attr"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns04.xml.unknown |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns04"> |
| <metadata> |
| <title>namednodemapsetnameditemns04</title> |
| <creator>IBM</creator> |
| <description> |
| The method setNamedItemNS adds a node using its namespaceURI and localName and |
| raises a WRONG_DOCUMENT_ERR if arg was created from a different document than the |
| one that created this map. |
| Retreieve the second element whose local name is address and its attribute into a named node map. |
| Create a new document and a new attribute node in it. Call the setNamedItemNS using the first |
| namedNodeMap and the new attribute node attribute of the new document. This should |
| raise a WRONG_DOCUMENT_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docAlt" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="attrAlt" type="Attr"/> |
| <var name="newNode" type="Node"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="docAlt" obj="domImpl" namespaceURI="nullNS" qualifiedName='"newDoc"' doctype="docType"/> |
| <createAttributeNS var="attrAlt" obj="docAlt" namespaceURI="nullNS" qualifiedName='"street"'/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <setNamedItemNS var="newNode" obj="attributes" arg="attrAlt"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns05.xml.unknown |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns05"> |
| <metadata> |
| <title>namednodemapsetnameditemns05</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive an entity and notation node and add the first notation to the |
| notation node map and first entity node to the entity map. Since both these |
| maps are for readonly node, a NO_MODIFICATION_ALLOWED_ERR should be raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=407"/> |
| <subject resource="http://lists.w3.org/Archives/Member/w3c-dom-ig/2003Nov/0016.html"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="notation" type="Notation"/> |
| <var name="newNode" type="Node"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entities" obj="docType"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <notations var="notations" obj="docType"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem var="entity" obj="entities" name='"ent1"'/> |
| <getNamedItem var="notation" obj="notations" name='"notation1"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_entities"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setNamedItemNS var="newNode" obj="entities" arg="entity"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_notations"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setNamedItemNS var="newNode" obj="notations" arg="notation"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns06.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns06"> |
| <metadata> |
| <title>namednodemapsetnameditemns06</title> |
| <creator>IBM</creator> |
| <description> |
| Retreieve the first element whose localName is address and its attributes into a named node map. |
| Retreiving the domestic attribute from the namednodemap. |
| Retreieve the second element whose localName is address and its attributes into a named node map. |
| Invoke setNamedItemNS on the second NamedNodeMap specifying the first domestic attribute from |
| the first map. This should raise an INUSE_ATTRIBIUTE_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="newNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <getNamedItemNS var="attr" obj="attributes" namespaceURI='"http://www.usa.com"' localName='"domestic"'/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <assertDOMException id="namednodemapsetnameditemns06"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setNamedItemNS var="newNode" obj="attributes" arg="attr"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns07.xml.unknown |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns07"> |
| <metadata> |
| <title>namednodemapsetnameditemns07</title> |
| <creator>IBM</creator> |
| <description> |
| The method setNamedItemNS adds a node using its namespaceURI and localName and |
| raises a INUSE_ATTRIBUTE_ERR Raised if arg is an Attr that is already an |
| attribute of another Element object. |
| Retreieve the attributes of first element whose localName is address into a named node map. |
| Retreive the attribute whose namespaceURI=http://www.usa.com and localName=domestic |
| from the NamedNodeMap. Retreieve the attributes of second element whose localName is address |
| into a named node map. Call the setNamedItemNS method on the second nodemap with the domestic |
| attribute that was retreived and removed from the first nodeMap as an argument. |
| Assuming that when an attribute is removed from a nodemap, it still remains in the domtree |
| his should raise an INUSE_ATTRIBIUTE_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="newNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <getNamedItemNS var="attr" obj="attributes" namespaceURI='"http://www.usa.com"' localName='"domestic"'/> |
| <!-- |
| <removeNamedItemNS obj="attributes" namespaceURI='"http://www.usa.com"' localName='"domestic"'/>; |
| --> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <assertDOMException id="namednodemapsetnameditemns07"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setNamedItemNS var="newNode" obj="attributes" arg="attr"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns08.xml.unknown |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns08"> |
| <metadata> |
| <title>namednodemapsetnameditemns08</title> |
| <creator>IBM</creator> |
| <description> |
| raises a INUSE_ATTRIBUTE_ERR Raised if arg is an Attr that is already an |
| attribute of another Element object. |
| Retreieve the first element whose localName is address and its attributes into a named node map. |
| Retreiving the domestic attribute from the namednodemap. Retreieve the second element whose |
| localName is address and its attributes into a named node map. Invoke setNamedItemNS on the |
| second NamedNodeMap specifying the attribute from the first map. |
| This should raise an INUSE_ATTRIBIUTE_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="newNode" type="Node"/> |
| <!-- |
| <var name="attrCloned" type="Attr"/> |
| --> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"*"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <getNamedItemNS var="attr" obj="attributes" namespaceURI='"http://www.usa.com"' localName='"domestic"'/> |
| <!-- |
| <cloneNode var="attrCloned" obj="attr" deep="true"/> |
| --> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <assertDOMException id="namednodemapsetnameditemns08"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setNamedItemNS var="newNode" obj="attributes" arg="attr"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns09.xml.unknown |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns09"> |
| <metadata> |
| <title>namednodemapsetnameditemns09</title> |
| <creator>IBM</creator> |
| <description> |
| The method setNamedItemNS adds a node using its namespaceURI and localName and |
| raises a NO_MODIFICATION_ALLOWED_ERR if this map is readonly. |
| Create a new attribute node and attempt to add it to the nodemap of entities and notations |
| for this documenttype. This should reaise a NO_MODIFICATION_ALLOWED_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="newNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entities" obj="docType"/> |
| <notations var="notations" obj="docType"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"test"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_entities"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setNamedItemNS var="newNode" obj="entities" arg="attr"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_notations"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setNamedItemNS var="newNode" obj="notations" arg="attr"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns10.xml.unknown |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns10"> |
| <metadata> |
| <title>namednodemapsetnameditemns10</title> |
| <creator>IBM</creator> |
| <description> |
| The method setNamedItemNS adds a node using its namespaceURI and localName and |
| raises a HIERARCHY_REQUEST_ERR if an attempt is made to add a node doesn't belong |
| in this NamedNodeMap. |
| Attempt to add an entity to a NamedNodeMap of attribute nodes, |
| Since nodes of this type cannot be added to the attribute node map a HIERARCHY_REQUEST_ERR |
| should be raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="notation" type="Notation"/> |
| <var name="element" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entities" obj="docType"/> |
| <assertNotNull actual="entities" id="entitiesNotNull"/> |
| <getNamedItem var="entity" obj="entities" name='"ent1"'/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"http://www.nist.gov"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <setNamedItemNS var="newNode" obj="attributes" arg="entity"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namednodemapsetnameditemns11.xml.unknown |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namednodemapsetnameditemns11"> |
| <metadata> |
| <title>namednodemapsetnameditemns11</title> |
| <creator>IBM</creator> |
| <description> |
| The method setNamedItemNS adds a node using its namespaceURI and localName and |
| raises a HIERARCHY_REQUEST_ERR if an attempt is made to add a node doesn't belong |
| in this NamedNodeMap. |
| Attempt to add a notation node to a NamedNodeMap of attribute nodes, |
| Since notations nodes do not belong in the attribute node map a HIERARCHY_REQUEST_ERR |
| should be raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="element" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="newNode" type="Node"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notations" obj="docType"/> |
| <assertNotNull actual="notations" id="notationsNotNull"/> |
| <getNamedItem var="notation" obj="notations" name='"notation1"'/> |
| <getElementsByTagNameNS var="elementList" obj="doc" namespaceURI='"http://www.nist.gov"' localName='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <attributes var="attributes" obj="element"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <setNamedItemNS var="newNode" obj="attributes" arg="notation"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namespaceURI01.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namespaceURI01"> |
| <metadata> |
| <title>namespaceURI01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNamespaceURI()" method for an Attribute |
| returns the namespace URI of this node, or null if unspecified. |
| Retrieve the first "emp:address" node which has an attribute of "emp:district" |
| that is specified in the DTD. |
| Invoke the "getNamespaceURI()" method on the attribute. |
| The method should return "http://www.nist.gov". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSname"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=238"/> |
| </metadata> |
| <!-- this test requires namespace awareness and validation --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="attrNamespaceURI" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"emp:address"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <getAttributeNodeNS obj="testAddr" namespaceURI='"http://www.nist.gov"' localName='"district"' var="addrAttr"/> |
| <namespaceURI obj="addrAttr" var="attrNamespaceURI"/> |
| <assertEquals actual="attrNamespaceURI" expected='"http://www.nist.gov"' id="namespaceURI" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namespaceURI02.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namespaceURI02"> |
| <metadata> |
| <title>namespaceURI02</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNamespaceURI()" method for an Attribute |
| returns the namespace URI of this node, or null if unspecified. |
| Retrieve the first emp:address node and get the emp:domestic attribute. |
| Invoke the "getNamespaceURI()" method on the attribute. |
| The method should return "http://www.nist.gov". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSname"/> |
| </metadata> |
| <!-- this test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="attrNamespaceURI" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"emp:address"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testAddr"/> |
| <assertNotNull actual="testAddr" id="empAddressNotNull"/> |
| <getAttributeNodeNS obj="testAddr" localName='"domestic"' namespaceURI='"http://www.nist.gov"' var="addrAttr"/> |
| <namespaceURI obj="addrAttr" var="attrNamespaceURI"/> |
| <assertEquals actual="attrNamespaceURI" expected='"http://www.nist.gov"' id="namespaceURI" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namespaceURI03.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namespaceURI03"> |
| <metadata> |
| <title>namespaceURI03</title> |
| <creator>NIST</creator> |
| <description> |
| The "getNamespaceURI()" method for a Node |
| returns the namespace URI of this node, or null if unspecified. |
| Retrieve the first employee node and invoke the "getNamespaceURI()" |
| method. The method should return "http://www.nist.gov". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSname"/> |
| </metadata> |
| <!-- this test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="employeeNamespace" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <assertNotNull actual="testEmployee" id="employeeNotNull"/> |
| <namespaceURI obj="testEmployee" var="employeeNamespace"/> |
| <assertEquals actual="employeeNamespace" expected='"http://www.nist.gov"' id="namespaceURI" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/namespaceURI04.xml.unknown |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="namespaceURI04"> |
| <metadata> |
| <title>namespaceURI04</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the second employee node and invoke the "getNamespaceURI()" |
| method. The method should return "null". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSname"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="employeeNamespace" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="testEmployee"/> |
| <namespaceURI obj="testEmployee" var="employeeNamespace"/> |
| <if><contentType type="image/svg+xml"/> |
| <!-- the element is staffNS.svg has a non-null namespace |
| but since namespace awareness is not asserted, |
| the namespaceURI may be null --> |
| <assertTrue id="employeeNS_svg"> |
| <or> |
| <isNull obj="employeeNamespace"/> |
| <equals actual="employeeNamespace" |
| expected='"http://www.w3.org/2001/DOM-Test-Suite/Level-2/Files"' |
| ignoreCase="false"/> |
| </or> |
| </assertTrue> |
| <else> |
| <assertNull actual="employeeNamespace" id="employeeNS_null"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodegetlocalname03.xml.unknown |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodegetlocalname03"> |
| <metadata> |
| <title>nodegetlocalname03</title> |
| <creator>IBM</creator> |
| <description> |
| The method getLocalName returns the local part of the qualified name of this node. |
| Ceate two new element nodes and atribute nodes, with and without namespace prefixes. |
| Retreive the local part of their qualified names using getLocalName and verrify |
| if it is correct. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSLocalN"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="qelement" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="qattr" type="Attr"/> |
| <var name="localElemName" type="DOMString"/> |
| <var name="localQElemName" type="DOMString"/> |
| <var name="localAttrName" type="DOMString"/> |
| <var name="localQAttrName" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/elem"' qualifiedName='"elem"'/> |
| <createElementNS var="qelement" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/elem"' qualifiedName='"qual:qelem"'/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/attr"' qualifiedName='"attr"'/> |
| <createAttributeNS var="qattr" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/attr"' qualifiedName='"qual:qattr"'/> |
| <localName var="localElemName" obj="element"/> |
| <localName var="localQElemName" obj="qelement"/> |
| <localName var="localAttrName" obj="attr"/> |
| <localName var="localQAttrName" obj="qattr"/> |
| <assertEquals actual="localElemName" expected='"elem"' id="nodegetlocalname03_localElemName" ignoreCase="false"/> |
| <assertEquals actual="localQElemName" expected='"qelem"' id="nodegetlocalname03_localQElemName" ignoreCase="false"/> |
| <assertEquals actual="localAttrName" expected='"attr"' id="nodegetlocalname03_localAttrName" ignoreCase="false"/> |
| <assertEquals actual="localQAttrName" expected='"qattr"' id="nodegetlocalname03_localQAttrName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodegetnamespaceuri03.xml.unknown |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodegetnamespaceuri03"> |
| <metadata> |
| <title>nodegetnamespaceuri03</title> |
| <creator>IBM</creator> |
| <description> |
| The method getNamespaceURI returns the namespace URI of this node, or null if it is unspecified |
| For nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE and nodes created with |
| a DOM Level 1 method, such as createElement from the Document interface, this is always null. |
| Ceate two new element nodes and atribute nodes, with and without namespace prefixes. |
| Retreive their namespaceURI's using getNamespaceURI and verrify if it is correct. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSname"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="elementNS" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrNS" type="Attr"/> |
| <var name="elemNSURI" type="DOMString"/> |
| <var name="elemNSURINull" type="DOMString"/> |
| <var name="attrNSURI" type="DOMString"/> |
| <var name="attrNSURINull" type="DOMString"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createElementNS var="element" obj="doc" namespaceURI="nullNS" qualifiedName='"elem"'/> |
| <createElementNS var="elementNS" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/elem"' qualifiedName='"qual:qelem"'/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI="nullNS" qualifiedName='"attr"'/> |
| <createAttributeNS var="attrNS" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/attr"' qualifiedName='"qual:qattr"'/> |
| <namespaceURI var="elemNSURI" obj="elementNS"/> |
| <namespaceURI var="elemNSURINull" obj="element"/> |
| <namespaceURI var="attrNSURI" obj="attrNS"/> |
| <namespaceURI var="attrNSURINull" obj="attr"/> |
| <assertEquals actual="elemNSURI" expected='"http://www.w3.org/DOM/Test/elem"' id="nodegetnamespaceuri03_elemNSURI" ignoreCase="false"/> |
| <assertNull actual="elemNSURINull" id="nodegetnamespaceuri03_1"/> |
| <assertEquals actual="attrNSURI" expected='"http://www.w3.org/DOM/Test/attr"' id="nodegetnamespaceuri03_attrNSURI" ignoreCase="false"/> |
| <assertNull actual="attrNSURINull" id="nodegetnamespaceuri03_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodegetownerdocument01.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodegetownerdocument01"> |
| <metadata> |
| <title>nodegetownerdocument01</title> |
| <creator>IBM</creator> |
| <description> |
| The method getOwnerDocument returns the Document object associated with this node |
| Create a new DocumentType node. Since this node is not used with any Document yet |
| verify if the ownerDocument is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#node-ownerDoc"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="ownerDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="nullID" type="DOMString" isNull="true"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="docType" obj="domImpl" qualifiedName='"mydoc"' publicId="nullID" systemId="nullID"/> |
| <ownerDocument var="ownerDoc" obj="docType"/> |
| <assertNull actual="ownerDoc" id="nodegetownerdocument01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodegetownerdocument02.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodegetownerdocument02"> |
| <metadata> |
| <title>nodegetownerdocument02</title> |
| <creator>IBM</creator> |
| <description> |
| The method getOwnerDocument returns the Document object associated with this node |
| Create a new Document node. Since this node is not used with any Document yet |
| verify if the ownerDocument is null. Create a new element Node on the new Document |
| object. Check the ownerDocument of the new element node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#node-ownerDoc"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="newElem" type="Element"/> |
| <var name="ownerDocDoc" type="Document"/> |
| <var name="ownerDocElem" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="docType" obj="domImpl" qualifiedName='"mydoc"' publicId="nullNS" systemId="nullNS"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"mydoc"' doctype="docType"/> |
| <ownerDocument var="ownerDocDoc" obj="newDoc"/> |
| <assertNull actual="ownerDocDoc" id="nodegetownerdocument02_1"/> |
| <createElementNS var="newElem" obj="newDoc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"myelem"'/> |
| <ownerDocument var="ownerDocElem" obj="newElem"/> |
| <assertNotNull actual="ownerDocElem" id="nodegetownerdocument02_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodegetprefix03.xml.unknown |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodegetprefix03"> |
| <metadata> |
| <title>nodegetprefix03</title> |
| <creator>IBM</creator> |
| <description> |
| The method getPrefix returns the namespace prefix of this node, or null if it is unspecified. |
| Ceate two new element nodes and atribute nodes, with and without namespace prefixes. |
| Retreive the prefix part of their qualified names using getPrefix and verify |
| if it is correct. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="qelement" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="qattr" type="Attr"/> |
| <var name="elemNoPrefix" type="DOMString"/> |
| <var name="elemPrefix" type="DOMString"/> |
| <var name="attrNoPrefix" type="DOMString"/> |
| <var name="attrPrefix" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/elem"' qualifiedName='"elem"'/> |
| <createElementNS var="qelement" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/elem"' qualifiedName='"qual:qelem"'/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/attr"' qualifiedName='"attr"'/> |
| <createAttributeNS var="qattr" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/attr"' qualifiedName='"qual:qattr"'/> |
| <prefix var="elemNoPrefix" obj="element"/> |
| <prefix var="elemPrefix" obj="qelement"/> |
| <prefix var="attrNoPrefix" obj="attr"/> |
| <prefix var="attrPrefix" obj="qattr"/> |
| <assertNull actual="elemNoPrefix" id="nodegetprefix03_1"/> |
| <assertEquals actual="elemPrefix" expected='"qual"' id="nodegetprefix03_2" ignoreCase="false"/> |
| <assertNull actual="attrNoPrefix" id="nodegetprefix03_3"/> |
| <assertEquals actual="attrPrefix" expected='"qual"' id="nodegetprefix03_4" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodehasattributes01.xml.unknown |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodehasattributes01"> |
| <metadata> |
| <title>nodehasattributes01</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttributes returns whether this node (if it is an element) has any attributes. |
| Retreive an element node without attributes. Verify if hasAttributes returns false. |
| Retreive another element node with attributes. Verify if hasAttributes returns true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeHasAttrs"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="hasAttributes" type="boolean"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName var="elementList" obj="doc" tagname='"employeeId"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <hasAttributes var="hasAttributes" obj="element"/> |
| <assertFalse actual="hasAttributes" id="employeeIdHasAttributesFalse"/> |
| <getElementsByTagName var="elementList" obj="doc" tagname='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <hasAttributes var="hasAttributes" obj="element"/> |
| <assertTrue actual="hasAttributes" id="addressHasAttributesTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodehasattributes02.xml.unknown |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodehasattributes02"> |
| <metadata> |
| <title>nodehasattributes02</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttributes returns whether this node (if it is an element) has any attributes. |
| Retrieve the docType node. Since this is not an element node check if hasAttributes returns |
| null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeHasAttrs"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="hasAttributes" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <hasAttributes var="hasAttributes" obj="docType"/> |
| <assertFalse actual="hasAttributes" id="nodehasattributes02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodehasattributes03.xml.unknown |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodehasattributes03"> |
| <metadata> |
| <title>nodehasattributes03</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttributes returns whether this node (if it is an element) has any attributes. |
| Retreive an element node with a default attributes. Verify if hasAttributes returns true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeHasAttrs"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="hasAttributes" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName var="elementList" obj="doc" tagname='"emp:employee"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <assertNotNull actual="element" id="empEmployeeNotNull"/> |
| <hasAttributes var="hasAttributes" obj="element"/> |
| <assertTrue actual="hasAttributes" id="hasAttributes"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodehasattributes04.xml.unknown |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodehasattributes04"> |
| <metadata> |
| <title>nodehasattributes04</title> |
| <creator>IBM</creator> |
| <description> |
| The method hasAttributes returns whether this node (if it is an element) has any attributes. |
| Create a new Document, Element and Attr node. Add the Attr to the Element and append the |
| Element to the Document. Retreive the newly created element node from the document and check |
| if it has attributes using hasAttributes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeHasAttrs"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="element" type="Element"/> |
| <var name="elementTest" type="Element"/> |
| <var name="elementDoc" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="setNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="hasAttributes" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"test"' doctype="docType"/> |
| <createElementNS var="element" obj="newDoc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom:elem"'/> |
| <createAttribute var="attribute" obj="newDoc" name='"attr"'/> |
| <setAttributeNode var="setNode" obj="element" newAttr="attribute"/> |
| <documentElement var="elementDoc" obj="newDoc"/> |
| <appendChild var="appendedChild" obj="elementDoc" newChild="element"/> |
| <getElementsByTagNameNS var="elementList" obj="newDoc" namespaceURI='"http://www.w3.org/DOM/Test"' localName='"elem"' interface="Document"/> |
| <item var="elementTest" obj="elementList" index="0" interface="NodeList"/> |
| <hasAttributes var="hasAttributes" obj="elementTest"/> |
| <assertTrue actual="hasAttributes" id="nodehasattributes04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodeissupported01.xml.unknown |
|---|
| 0,0 → 1,70 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodeissupported01"> |
| <metadata> |
| <title>nodeissupported01</title> |
| <creator>IBM</creator> |
| <description> |
| The method "isSupported(feature,version)" Tests whether the DOM implementation |
| implements a specific feature and that feature is supported by this node. |
| Call the isSupported method on the document element node with a combination of features |
| versions and versions as below. Valid feature names are case insensitive and versions |
| "2.0", "1.0" and if the version is not specified, supporting any version of the feature |
| should return true. Check if the value returned value was true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="version" type="DOMString" value=""""/> |
| <var name="version1" type="DOMString" value=""1.0""/> |
| <var name="version2" type="DOMString" value=""2.0""/> |
| <var name="featureCore" type="DOMString"/> |
| <var name="featureXML" type="DOMString"/> |
| <var name="success" type="boolean"/> |
| <var name="featuresXML" type="List"> |
| <member>"XML"</member> |
| <member>"xmL"</member> |
| </var> |
| <var name="featuresCore" type="List"> |
| <member>"Core"</member> |
| <member>"CORE"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <documentElement obj="doc" var="element"/> |
| <for-each collection="featuresXML" member="featureXML"> |
| <isSupported obj="element" var="success" feature="featureXML" version="version"/> |
| <assertTrue actual="success" id="nodeissupported01_XML1"/> |
| <isSupported obj="element" var="success" feature="featureXML" version="version1"/> |
| <assertTrue actual="success" id="nodeissupported01_XML2"/> |
| </for-each> |
| <for-each collection="featuresCore" member="featureCore"> |
| <isSupported obj="element" var="success" feature="featureCore" version="version"/> |
| <assertTrue actual="success" id="nodeissupported01_Core1"/> |
| <!-- isSupported("Core", "1.0") is unspecified since "Core" was not defined in L1 --> |
| <isSupported obj="element" var="success" feature="featureCore" version="version1"/> |
| <isSupported obj="element" var="success" feature="featureCore" version="version2"/> |
| <assertTrue actual="success" id="nodeissupported01_Core3"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodeissupported02.xml.unknown |
|---|
| 0,0 → 1,70 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodeissupported02"> |
| <metadata> |
| <title>nodeissupported02</title> |
| <creator>IBM</creator> |
| <description> |
| The method "isSupported(feature,version)" Tests whether the DOM implementation |
| implements a specific feature and that feature is supported by this node. |
| Call the isSupported method on a new attribute node with a combination of features |
| versions and versions as below. Valid feature names are case insensitive and versions |
| "2.0", "1.0" and if the version is not specified, supporting any version of the feature |
| should return true. Check if the value returned value was true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attribute" type="Attr"/> |
| <var name="version" type="DOMString" value=""""/> |
| <var name="version1" type="DOMString" value=""1.0""/> |
| <var name="version2" type="DOMString" value=""2.0""/> |
| <var name="featureCore" type="DOMString"/> |
| <var name="featureXML" type="DOMString"/> |
| <var name="success" type="boolean"/> |
| <var name="featuresXML" type="List"> |
| <member>"XML"</member> |
| <member>"xmL"</member> |
| </var> |
| <var name="featuresCore" type="List"> |
| <member>"Core"</member> |
| <member>"CORE"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createAttribute obj="doc" var="attribute" name='"TestAttr"'/> |
| <for-each collection="featuresXML" member="featureXML"> |
| <isSupported obj="attribute" var="success" feature="featureXML" version="version"/> |
| <assertTrue actual="success" id="nodeissupported02_XML1"/> |
| <isSupported obj="attribute" var="success" feature="featureXML" version="version1"/> |
| <assertTrue actual="success" id="nodeissupported02_XML2"/> |
| </for-each> |
| <for-each collection="featuresCore" member="featureCore"> |
| <isSupported obj="attribute" var="success" feature="featureCore" version="version"/> |
| <assertTrue actual="success" id="nodeissupported02_Core1"/> |
| <!-- isSupported("Core", "1.0") is unspecified since "Core" was not defined in L1 --> |
| <isSupported obj="attribute" var="success" feature="featureCore" version="version1"/> |
| <isSupported obj="attribute" var="success" feature="featureCore" version="version2"/> |
| <assertTrue actual="success" id="nodeissupported02_Core3"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodeissupported03.xml.unknown |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodeissupported03"> |
| <metadata> |
| <title>nodeissupported03</title> |
| <creator>IBM</creator> |
| <description> |
| The method "isSupported(feature,version)" Tests whether the DOM implementation |
| implements a specific feature and that feature is supported by this node. |
| Call the isSupported method specifying empty strings for feature and version on a docType |
| Node. Check if the value returned value was false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="success" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <isSupported obj="docType" var="success" feature='""' version='""'/> |
| <assertFalse actual="success" id="nodeissupported03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodeissupported04.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodeissupported04"> |
| <metadata> |
| <title>nodeissupported04</title> |
| <creator>IBM</creator> |
| <description> |
| The method "isSupported(feature,version)" Tests whether the DOM implementation |
| implements a specific feature and that feature is supported by this node. |
| Call the isSupported method specifying empty strings for feature and version on a |
| new EntityReference node. Check if the value returned value was false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="success" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent1"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <isSupported obj="entRef" var="success" feature='"XML CORE"' version='""'/> |
| <assertFalse actual="success" id="nodeissupported04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodeissupported05.xml.unknown |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodeissupported05"> |
| <metadata> |
| <title>nodeissupported05</title> |
| <creator>IBM</creator> |
| <description> |
| The method "isSupported(feature,version)" Tests whether the DOM implementation |
| implements a specific feature and that feature is supported by this node. |
| Call the isSupported method specifying bad values for feature and version on a new |
| Processing Instruction node. Check if the value returned from this method value was false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="success" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createProcessingInstruction var="pi" obj="doc" target='"PITarget"' data='"PIData"'/> |
| <isSupported obj="pi" var="success" feature='"-"' version='"+"'/> |
| <assertFalse actual="success" id="nodeissupported05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodenormalize01.xml.unknown |
|---|
| 0,0 → 1,153 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodenormalize01"> |
| <metadata> |
| <title>nodenormalize01</title> |
| <creator>IBM</creator> |
| <description> |
| The method "normalize" puts all Text nodes in the full depth of the sub-tree underneath |
| this Node, including attribute nodes, into a "normal" form where only structure |
| (e.g., elements, comments, processing instructions, CDATA sections, and entity references) |
| separates Text nodes, i.e., there are neither adjacent Text nodes nor empty Text nodes. |
| Create a dom tree consisting of elements, comments, processing instructions, CDATA sections, |
| and entity references nodes seperated by text nodes. Check the length of the node list of each |
| before and after normalize has been called. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-normalize"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="docTypeNull" type="DocumentType" isNull="true"/> |
| <var name="documentElement" type="Element"/> |
| <var name="element1" type="Element"/> |
| <var name="element2" type="Element"/> |
| <var name="element3" type="Element"/> |
| <var name="element4" type="Element"/> |
| <var name="element5" type="Element"/> |
| <var name="element6" type="Element"/> |
| <var name="element7" type="Element"/> |
| <var name="text1" type="Text"/> |
| <var name="text2" type="Text"/> |
| <var name="text3" type="Text"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="cData" type="CDATASection"/> |
| <var name="comment" type="Comment"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom:root"' doctype="docTypeNull"/> |
| <createElement var="element1" obj="newDoc" tagName='"element1"'/> |
| <createElement var="element2" obj="newDoc" tagName='"element2"'/> |
| <createElement var="element3" obj="newDoc" tagName='"element3"'/> |
| <createElement var="element4" obj="newDoc" tagName='"element4"'/> |
| <createElement var="element5" obj="newDoc" tagName='"element5"'/> |
| <createElement var="element6" obj="newDoc" tagName='"element6"'/> |
| <createElement var="element7" obj="newDoc" tagName='"element7"'/> |
| <createTextNode var="text1" obj="newDoc" data='"text1"'/> |
| <createTextNode var="text2" obj="newDoc" data='"text2"'/> |
| <createTextNode var="text3" obj="newDoc" data='"text3"'/> |
| <createCDATASection var="cData" obj="newDoc" data='"Cdata"'/> |
| <createComment var="comment" obj="newDoc" data='"comment"'/> |
| <createProcessingInstruction var="pi" obj="newDoc" target='"PITarget"' data='"PIData"'/> |
| <createEntityReference var="entRef" obj="newDoc" name='"EntRef"'/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| <documentElement var="documentElement" obj="newDoc"/> |
| <appendChild var="appendedChild" obj="documentElement" newChild="element1"/> |
| <appendChild var="appendedChild" obj="element2" newChild="text1"/> |
| <appendChild var="appendedChild" obj="element2" newChild="text2"/> |
| <appendChild var="appendedChild" obj="element2" newChild="text3"/> |
| <appendChild var="appendedChild" obj="element1" newChild="element2"/> |
| <cloneNode var="text1" obj="text1" deep="false"/> |
| <cloneNode var="text2" obj="text2" deep="false"/> |
| <appendChild var="appendedChild" obj="element3" newChild="entRef"/> |
| <appendChild var="appendedChild" obj="element3" newChild="text1"/> |
| <appendChild var="appendedChild" obj="element3" newChild="text2"/> |
| <appendChild var="appendedChild" obj="element1" newChild="element3"/> |
| <cloneNode var="text1" obj="text1" deep="false"/> |
| <cloneNode var="text2" obj="text2" deep="false"/> |
| <appendChild var="appendedChild" obj="element4" newChild="cData"/> |
| <appendChild var="appendedChild" obj="element4" newChild="text1"/> |
| <appendChild var="appendedChild" obj="element4" newChild="text2"/> |
| <appendChild var="appendedChild" obj="element1" newChild="element4"/> |
| <cloneNode var="text2" obj="text2" deep="false"/> |
| <cloneNode var="text3" obj="text3" deep="false"/> |
| <appendChild var="appendedChild" obj="element5" newChild="comment"/> |
| <appendChild var="appendedChild" obj="element5" newChild="text2"/> |
| <appendChild var="appendedChild" obj="element5" newChild="text3"/> |
| <appendChild var="appendedChild" obj="element1" newChild="element5"/> |
| <cloneNode var="text2" obj="text2" deep="false"/> |
| <cloneNode var="text3" obj="text3" deep="false"/> |
| <appendChild var="appendedChild" obj="element6" newChild="pi"/> |
| <appendChild var="appendedChild" obj="element6" newChild="text2"/> |
| <appendChild var="appendedChild" obj="element6" newChild="text3"/> |
| <appendChild var="appendedChild" obj="element1" newChild="element6"/> |
| <cloneNode var="entRef" obj="entRef" deep="false"/> |
| <cloneNode var="text1" obj="text1" deep="false"/> |
| <cloneNode var="text2" obj="text2" deep="false"/> |
| <cloneNode var="text3" obj="text3" deep="false"/> |
| <appendChild var="appendedChild" obj="element7" newChild="entRef"/> |
| <appendChild var="appendedChild" obj="element7" newChild="text1"/> |
| <appendChild var="appendedChild" obj="element7" newChild="text2"/> |
| <appendChild var="appendedChild" obj="element7" newChild="text3"/> |
| <appendChild var="appendedChild" obj="element1" newChild="element7"/> |
| <childNodes var="elementList" obj="element1"/> |
| <assertSize size="6" collection="elementList" id="nodeNormalize01_1Bef"/> |
| <childNodes var="elementList" obj="element2"/> |
| <assertSize size="3" collection="elementList" id="nodeNormalize01_2Bef"/> |
| <childNodes var="elementList" obj="element3"/> |
| <assertSize size="3" collection="elementList" id="nodeNormalize01_3Bef"/> |
| <childNodes var="elementList" obj="element4"/> |
| <assertSize size="3" collection="elementList" id="nodeNormalize01_4Bef"/> |
| <childNodes var="elementList" obj="element5"/> |
| <assertSize size="3" collection="elementList" id="nodeNormalize01_5Bef"/> |
| <childNodes var="elementList" obj="element6"/> |
| <assertSize size="3" collection="elementList" id="nodeNormalize01_6Bef"/> |
| <childNodes var="elementList" obj="element7"/> |
| <assertSize size="4" collection="elementList" id="nodeNormalize01_7Bef"/> |
| <normalize obj="newDoc"/> |
| <childNodes var="elementList" obj="element1"/> |
| <assertSize size="6" collection="elementList" id="nodeNormalize01_1Aft"/> |
| <childNodes var="elementList" obj="element2"/> |
| <assertSize size="1" collection="elementList" id="nodeNormalize01_2Aft"/> |
| <childNodes var="elementList" obj="element3"/> |
| <assertSize size="2" collection="elementList" id="nodeNormalize01_3Aft"/> |
| <childNodes var="elementList" obj="element4"/> |
| <assertSize size="2" collection="elementList" id="nodeNormalize01_4Aft"/> |
| <childNodes var="elementList" obj="element5"/> |
| <assertSize size="2" collection="elementList" id="nodeNormalize01_5Aft"/> |
| <childNodes var="elementList" obj="element6"/> |
| <assertSize size="2" collection="elementList" id="nodeNormalize01_6Aft"/> |
| <childNodes var="elementList" obj="element7"/> |
| <assertSize size="2" collection="elementList" id="nodeNormalize01_7Aft"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodesetprefix01.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodesetprefix01"> |
| <metadata> |
| <title>nodesetprefix01</title> |
| <creator>IBM</creator> |
| <description> |
| The method setPrefix sets the namespace prefix of this node. Note that setting this attribute, |
| when permitted, changes the nodeName attribute, which holds the qualified name, as well as the |
| tagName and name attributes of the Element and Attr interfaces, when applicable. |
| Create a new element node with a namespace prefix. Add it to a new DocumentFragment Node without |
| a prefix. Call setPrefix on the elemen node. Check if the prefix was set correctly on the element. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="element" type="Element"/> |
| <var name="elementTagName" type="DOMString"/> |
| <var name="elementNodeName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <createDocumentFragment var="docFragment" obj="doc" /> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"emp:address"'/> |
| <appendChild var="appendedChild" obj="docFragment" newChild="element"/> |
| <prefix obj="element" value='"dmstc"'/> |
| <tagName var="elementTagName" obj="element"/> |
| <nodeName var="elementNodeName" obj="element"/> |
| <assertEquals actual="elementTagName" expected='"dmstc:address"' id="nodesetprefix01_tagname" ignoreCase="false"/> |
| <assertEquals actual="elementNodeName" expected='"dmstc:address"' id="nodesetprefix01_nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodesetprefix02.xml.unknown |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodesetprefix02"> |
| <metadata> |
| <title>nodesetprefix02</title> |
| <creator>IBM</creator> |
| <description> |
| The method setPrefix sets the namespace prefix of this node. Note that setting this attribute, |
| when permitted, changes the nodeName attribute, which holds the qualified name, as well as the |
| tagName and name attributes of the Element and Attr interfaces, when applicable. |
| Create a new attribute node and add it to an element node with an existing attribute having |
| the same localName as this attribute but different namespaceURI. Change the prefix of the |
| newly created attribute using setPrefix. Check if the new attribute nodeName has changed |
| and the existing attribute is the same. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="newAttribute" type="Attr"/> |
| <var name="setNode" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attrName" type="DOMString"/> |
| <var name="newAttrName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName var="elementList" obj="doc" tagname='"address"' interface="Document"/> |
| <item var="element" obj="elementList" index="1" interface="NodeList"/> |
| <createAttributeNS var="newAttribute" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"test:address"'/> |
| <setAttributeNodeNS var="setNode" obj="element" newAttr="newAttribute"/> |
| <prefix obj="newAttribute" value='"dom"'/> |
| <getAttributeNodeNS var="attribute" obj="element" namespaceURI='"http://www.usa.com"' localName='"domestic"'/> |
| <nodeName var="attrName" obj="attribute"/> |
| <nodeName var="newAttrName" obj="newAttribute"/> |
| <assertEquals actual="attrName" expected='"dmstc:domestic"' id="nodesetprefix02_attrName" ignoreCase="false"/> |
| <assertEquals actual="newAttrName" expected='"dom:address"' id="nodesetprefix02_newAttrName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodesetprefix03.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodesetprefix03"> |
| <metadata> |
| <title>nodesetprefix03</title> |
| <creator>IBM</creator> |
| <description> |
| The method setPrefix raises a NAMESPACE_ERR if the namespaceURI of this node is null. |
| Create a new element node without a namespace prefix. Call setPrefix on the newly created elemenent node. |
| Check if a NAMESPACE_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElement var="element" obj="doc" tagName='"address"'/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <prefix obj="element" value='"test"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodesetprefix04.xml.unknown |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodesetprefix04"> |
| <metadata> |
| <title>nodesetprefix04</title> |
| <creator>IBM</creator> |
| <description> |
| The method setPrefix raises a NAMESPACE_ERR if the namespaceURI of this node is null. |
| Retreive the a default Attribute node which does not have a namespace prefix. Call the setPrefix |
| method on it. Check if a NAMESPACE_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=259"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attribute" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName var="elementList" obj="doc" tagname='"emp:employee"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <assertNotNull actual="element" id="empEmployeeNotNull"/> |
| <getAttributeNodeNS var="attribute" obj="element" namespaceURI="nullNS" localName='"defaultAttr"'/> |
| <assertDOMException id="nodesetprefix04"> |
| <NAMESPACE_ERR> |
| <prefix obj="attribute" value='"test"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodesetprefix05.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodesetprefix05"> |
| <metadata> |
| <title>nodesetprefix05</title> |
| <creator>IBM</creator> |
| <description> |
| The method setPrefix raises a NAMESPACE_ERR if the specified prefix is malformed. |
| Create a new namespace aware element node and call the setPrefix method on it with several malformed |
| prefix values. Check if a NAMESPACE_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="prefixValue" type="DOMString"/> |
| <var name="prefixValues" type="List"> |
| <member>"_:"</member> |
| <member>":0"</member> |
| <member>":"</member> |
| <member>"_::"</member> |
| <member>"a:0:c"</member> |
| </var> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/L2"' qualifiedName='"dom:elem"'/> |
| <for-each collection="prefixValues" member="prefixValue"> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <prefix obj="element" value="prefixValue"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodesetprefix06.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodesetprefix06"> |
| <metadata> |
| <title>nodesetprefix06</title> |
| <creator>IBM</creator> |
| <description> |
| The method setPrefix raises a NAMESPACE_ERR if the specified prefix is "xml" and the namespaceURI |
| of this node is different from "http://www.w3.org/XML/1998/namespace". |
| Invoke the setPrefix method on this Element object with namespaceURI that is different from |
| http://www..w3.org/xml/1998/namespace and a prefix whose values is xml. |
| Check if the NAMESPACE_ERR was thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/L2"' qualifiedName='"dom:elem"'/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <prefix obj="element" value='"xml"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodesetprefix07.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodesetprefix07"> |
| <metadata> |
| <title>nodesetprefix07</title> |
| <creator>IBM</creator> |
| <description> |
| The method setPrefix raises a NAMESPACE_ERR if this node is an attribute and the specified |
| prefix is "xmlns" and the namespaceURI of this node is different from |
| "http://www.w3.org/2000/xmlns/". |
| Create a new attribute node whose namespaceURI is different form "http://www.w3.org/2000/xmlns/" |
| and node prefix is "xmlns". |
| Check if the NAMESPACE_ERR was thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attribute" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createAttributeNS var="attribute" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/L2"' qualifiedName='"abc:elem"'/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <prefix obj="attribute" value='"xmlns"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodesetprefix08.xml.unknown |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodesetprefix08"> |
| <metadata> |
| <title>nodesetprefix08</title> |
| <creator>IBM</creator> |
| <description> |
| The method setPrefix raises a NAMESPACE_ERR if this node is an attribute and the qualifiedName |
| of this node is "xmlns |
| Retreive an attribute node whose qualifiedName is xmlns. Try setting a prefix on this node. |
| Check if the NAMESPACE_ERR was thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="attribute" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName var="elementList" obj="doc" tagname='"employee"' interface="Document"/> |
| <item var="element" obj="elementList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attribute" obj="element" name='"xmlns"'/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <prefix obj="attribute" value='"xml"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/nodesetprefix09.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="nodesetprefix09"> |
| <metadata> |
| <title>nodesetprefix09</title> |
| <creator>IBM</creator> |
| <description> |
| The method setPrefix raises a INVALID_CHARACTER_ERR if the specified prefix contains an illegal character. |
| Create a new namespace aware element node and call the setPrefix method on it with a prefix having |
| an invalid character. Check if a NAMESPACE_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="value" type="DOMString" value='"#$%&'()@"' /> |
| <var name="element" type="Element"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test/L2"' qualifiedName='"dom:elem"'/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <prefix obj="element" value="value" /> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/normalize01.xml.unknown |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="normalize01"> |
| <metadata> |
| <title>normalize01</title> |
| <creator>NIST</creator> |
| <description> |
| The "normalize()" method puts all the nodes in the full |
| depth of the sub-tree underneath this element into a |
| "normal" form. |
| Retrieve the third employee and access its second child. |
| This child contains a block of text that is spread |
| across multiple lines. The content of the "name" child |
| should be parsed and treated as a single Text node. |
| This appears to be a duplicate of elementnormalize.xml in DOM L1 Test Suite |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-72AB8359"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="root" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="firstChild" type="Node"/> |
| <var name="textList" type="NodeList"/> |
| <var name="textNode" type="CharacterData"/> |
| <var name="data" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <normalize obj="root"/> |
| <getElementsByTagName interface="Element" obj="root" tagname='"name"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="2" var="firstChild"/> |
| <childNodes obj="firstChild" var="textList"/> |
| <item interface="NodeList" obj="textList" index="0" var="textNode"/> |
| <data interface="CharacterData" obj="textNode" var="data"/> |
| <assertEquals actual="data" expected='"Roger\n Jones"' id="data" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/ownerDocument01.xml.unknown |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="ownerDocument01"> |
| <metadata> |
| <title>ownerDocument01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getOwnerDocument()" method returns null if the target |
| node itself is a DocumentType which is not used with any document yet. |
| Invoke the "getOwnerDocument()" method on the master |
| document. The DocumentType returned should be null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#node-ownerDoc"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="ownerDocument" type="DocumentType"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <ownerDocument obj="doc" var="ownerDocument"/> |
| <assertNull actual="ownerDocument" id="throw_Null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/ownerElement01.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="ownerElement01"> |
| <metadata> |
| <title>ownerElement01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getOwnerElement()" will return the Element node this attribute |
| is attached to or null if this attribute is not in use. |
| Get the "domestic" attribute from the first "address" node. |
| Apply the "getOwnerElement()" method to get the Element associated |
| with the attribute. The value returned should be "address". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-F68D095"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="addressList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="domesticAttr" type="Attr"/> |
| <var name="elementNode" type="Element"/> |
| <var name="name" type="DOMString"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="addressList" tagname=""address""/> |
| <item interface="NodeList" obj="addressList" var="testNode" index="0"/> |
| <attributes obj="testNode" var="attributes"/> |
| <getNamedItem obj="attributes" var="domesticAttr" name=""domestic""/> |
| <ownerElement obj="domesticAttr" var="elementNode"/> |
| <nodeName obj="elementNode" var="name"/> |
| <assertEquals actual="name" expected=""address"" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/ownerElement02.xml.unknown |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="ownerElement02"> |
| <metadata> |
| <title>ownerElement02</title> |
| <creator>NIST</creator> |
| <description> |
| The "getOwnerElement()" will return the Element node this attribute |
| is attached to or null if this attribute is not in use. |
| Create a new attribute. |
| Apply the "getOwnerElement()" method to get the Element associated |
| with the attribute. The value returned should be "null" since this |
| attribute is not in use. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Attr-ownerElement"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="elementNode" type="Element"/> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createAttribute obj="doc" var="newAttr" name=""newAttribute""/> |
| <ownerElement obj="newAttr" var="elementNode"/> |
| <assertNull actual="elementNode" id="throw_Null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix01.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix01"> |
| <metadata> |
| <title>prefix01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getPrefix()" method for a Node |
| returns the namespace prefix of the node, |
| and for nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE |
| and nodes created with a DOM Level 1 method, this is null. |
| Create an new Element with the createElement() method. |
| Invoke the "getPrefix()" method on the newly created element |
| node will cause "null" to be returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="createdNode" type="Node"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createElement obj="doc" tagName=""test:employee"" var="createdNode"/> |
| <prefix obj="createdNode" var="prefix"/> |
| <assertNull actual="prefix" id="throw_Null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix02.xml.unknown |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix02"> |
| <metadata> |
| <title>prefix02</title> |
| <creator>NIST</creator> |
| <description> |
| The "getPrefix()" method |
| returns the namespace prefix of this node, or null if unspecified. |
| For nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE, |
| this is always null. |
| Retrieve the first emp:employeeId node and get the first child of this node. |
| Since the first child is Text node invoking the "getPrefix()" |
| method will cause "null" to be returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="textNode" type="Node"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"emp:employeeId"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <assertNotNull actual="testEmployee" id="empEmployeeNotNull"/> |
| <firstChild interface="Node" obj="testEmployee" var="textNode"/> |
| <prefix obj="textNode" var="prefix"/> |
| <assertNull actual="prefix" id="textNodePrefix"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix03.xml.unknown |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix03"> |
| <metadata> |
| <title>prefix03</title> |
| <creator>NIST</creator> |
| <description> |
| The "getPrefix()" method for a node |
| returns the namespace prefix of this node, or null if it is unspecified. |
| Retrieve the first emp:employee node and invoke the getPrefix() method." |
| The method should return "emp". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"emp:employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <assertNotNull actual="testEmployee" id="empEmployeeNotNull"/> |
| <prefix obj="testEmployee" var="prefix"/> |
| <assertEquals actual="prefix" expected='"emp"' id="prefix" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix04.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix04"> |
| <metadata> |
| <title>prefix04</title> |
| <creator>NIST</creator> |
| <description> |
| The "getPrefix()" method for a node |
| returns the namespace prefix of this node, or null if it is unspecified. |
| Retrieve the first employee node and invoke the getPrefix() method." |
| The method should return "null". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testEmployee" type="Node"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="testEmployee"/> |
| <prefix obj="testEmployee" var="prefix"/> |
| <assertNull actual="prefix" id="throw_Null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix05.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix05"> |
| <metadata> |
| <title>prefix05</title> |
| <creator>NIST</creator> |
| <description> |
| The "setPrefix(prefix)" method raises a |
| NAMESPACE_ERR DOMException if the specified node is an attribute |
| and the specified prefix is xmlns and the namespaceURI is different from |
| http://www.w3.org/2000/xmlns. |
| Attempt to insert "xmlns" as the new namespace prefix on the emp:domestic |
| attribute within the emp:address node. |
| An exception should be raised since the namespaceURI of this node is not |
| http://www.w3.org/2000/xmlns. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-NodeNSPrefix')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="addrNode" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""emp:address"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="addrNode"/> |
| <assertNotNull actual="addrNode" id="empAddrNotNull"/> |
| <getAttributeNode obj="addrNode" name=""emp:domestic"" var="addrAttr"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <prefix obj="addrAttr" value=""xmlns""/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix06.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix06"> |
| <metadata> |
| <title>prefix06</title> |
| <creator>NIST</creator> |
| <description> |
| The "setPrefix(prefix)" method raises a |
| INVALID_CHARACTER_ERR DOMException if the specified |
| prefix contains an illegal character. |
| Attempt to insert a new namespace prefix on the first employee node. |
| An exception should be raised since the namespace prefix has an invalid |
| character. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-NodeNSPrefix')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="employeeNode"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <prefix obj="employeeNode" value=""pre^fix xmlns='http//www.nist.gov'""/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix07.xml.unknown |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix07"> |
| <metadata> |
| <title>prefix07</title> |
| <creator>NIST</creator> |
| <description> |
| The "setPrefix(prefix)" method raises a |
| NAMESPACE_ERR DOMException if the specified |
| prefix if malformed. |
| Attempt to insert a new namespace prefix on the second employee node. |
| An exception should be raised since the namespace prefix is malformed. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-NodeNSPrefix')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="employeeNode"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <prefix obj="employeeNode" value=""emp::""/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix08.xml.unknown |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix08"> |
| <metadata> |
| <title>prefix08</title> |
| <creator>NIST</creator> |
| <description> |
| The "setPrefix(prefix)" method causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Get the FIRST item |
| from the entity reference and execute the "setPrefix(prefix)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-NodeNSPrefix')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="genderNode" type="Node"/> |
| <var name="entRef" type="Node"/> |
| <var name="entElement" type="Node"/> |
| <var name="createdNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"gender"' var="genderList"/> |
| <item interface="NodeList" obj="genderList" index="2" var="genderNode"/> |
| <firstChild interface="Node" obj="genderNode" var="entRef"/> |
| <nodeType var="nodeType" obj="entRef"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entRef" name='"ent4"' obj="doc"/> |
| <assertNotNull actual="entRef" id="createdEntRefNotNull"/> |
| </if> |
| <firstChild interface="Node" obj="entRef" var="entElement"/> |
| <assertNotNull actual="entElement" id="entElement"/> |
| <createElement obj="doc" tagName='"text3"' var="createdNode"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <prefix obj="entElement" value='"newPrefix"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix09.xml.unknown |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix09"> |
| <metadata> |
| <title>prefix09</title> |
| <creator>NIST</creator> |
| <description> |
| The "setPrefix(prefix)" method raises a |
| NAMESPACE_ERR DOMException if the specified node is an attribute |
| and the qualifiedName of this node is xmlns. |
| Attempt to set the prefix on the xmlns attribute within the fourth address |
| element. |
| An exception should be raised since the qualifiedName of this attribute |
| is "xmlns". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-NodeNSPrefix')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <!-- this test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="addrNode" type="Element"/> |
| <var name="addrAttr" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"address"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="3" var="addrNode"/> |
| <getAttributeNode obj="addrNode" name='"xmlns"' var="addrAttr"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <prefix obj="addrAttr" value='"xxx"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix10.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix10"> |
| <metadata> |
| <title>prefix10</title> |
| <creator>NIST</creator> |
| <description> |
| The "setPrefix(prefix)" method raises a |
| NAMESPACE_ERR DOMException if the specified |
| prefix is xml and the namespaceURI is different from |
| http://www.w3.org/XML/1998/namespace. |
| Attempt to insert "xml" as the new namespace prefix on the first employee node. |
| An exception should be raised since the namespaceURI of this node is not |
| http://www.w3.org/XML/1998/namespace. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-NodeNSPrefix"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-NodeNSPrefix')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname=""employee"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <prefix obj="employeeNode" value=""xml""/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/prefix11.xml.unknown |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="prefix11"> |
| <metadata> |
| <title>prefix11</title> |
| <creator>NIST</creator> |
| <description> |
| The "setPrefix(prefix)" method raises a |
| NAMESPACE_ERR DOMException if the specified |
| prefix is set on a node with a namespaceURI that is null. |
| Attempt to insert a new namespace prefix on the second employee node. |
| An exception should be raised since the namespace prefix is set |
| on a node whose namespaceURI is null. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('')/setraises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="employeeNode" type="Node"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"employee"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="1" var="employeeNode"/> |
| <!-- element has a NS in staffNS.svg, create an null NS'd element --> |
| <if><contentType type="image/svg+xml"/> |
| <createElementNS var="employeeNode" obj="doc" |
| namespaceURI="nullNS" qualifiedName='"employee"'/> |
| </if> |
| <namespaceURI obj="employeeNode" var="namespaceURI"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <prefix obj="employeeNode" value='"employee1"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| <assertNull actual="namespaceURI" id="employeeNS"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/publicId01.xml.unknown |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="publicId01"> |
| <metadata> |
| <title>publicId01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getPublicId()" method of a documenttype node contains |
| the public identifier associated with the external subset. |
| Retrieve the documenttype. |
| Apply the "getPublicId()" method. The string "STAFF" should be |
| returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-Core-DocType-publicId"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="publicId" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <publicId interface="DocumentType" obj="docType" var="publicId"/> |
| <assertEquals actual="publicId" expected=""STAFF"" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/removeAttributeNS01.xml.unknown |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="removeAttributeNS01"> |
| <metadata> |
| <title>removeAttributeNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeAttributeNS(namespaceURI,localName)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Try to remove an attribute |
| from the entity reference by executing the |
| "removeAttributeNS(namespaceURI,localName)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElRemAtNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-ElRemAtNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="gen" type="Node"/> |
| <var name="gList" type="NodeList"/> |
| <var name="genElement" type="Element"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <firstChild var="gen" obj="gender" interface="Node"/> |
| <nodeType var="nodeType" obj="gen"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference name='"ent4"' obj="doc" var="gen"/> |
| <assertNotNull actual="gen" id="createdEntRefNotNull"/> |
| </if> |
| <childNodes obj="gen" var="gList"/> |
| <item interface="NodeList" obj="gList" var="genElement" index="0"/> |
| <assertNotNull actual="genElement" id="notnull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeAttributeNS obj="genElement" namespaceURI='"www.xyz.com"' localName='"local1"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/removeAttributeNS02.xml.unknown |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="removeAttributeNS02"> |
| <metadata> |
| <title>removeAttributeNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeAttributeNS(namespaceURI,localName)" removes an attribute by |
| local name and namespace URI. If the removed attribute has a |
| default value it is immediately replaced. The replacing attribute has the same |
| namespace URI and local name, as well as the original prefix. |
| Retrieve the attribute named "emp:local" from emp:address |
| node, then remove the "emp:local" |
| attribute by invoking the "removeAttributeNS(namespaceURI,localName)" method. |
| The "emp:local" attribute has a default value defined in the |
| DTD file, that value should immediately replace the old |
| value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElRemAtNS"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=238"/> |
| </metadata> |
| <!-- this test requires namespace awareness and validation --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="attr" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="localName" type="DOMString"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""emp:address""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <removeAttributeNS obj="testAddr" namespaceURI='"http://www.nist.gov"' localName='"local1"'/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""emp:address""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <getAttributeNodeNS obj="testAddr" var="addrAttr" namespaceURI='"http://www.nist.gov"' localName='"local1"'/> |
| <getAttributeNS obj="testAddr" var="attr" namespaceURI='"http://www.nist.gov"' localName='"local1"'/> |
| <namespaceURI obj="addrAttr" var="namespaceURI"/> |
| <localName obj="addrAttr" var="localName"/> |
| <prefix obj="testAddr" var="prefix"/> |
| <assertEquals actual="attr" expected='"FALSE"' ignoreCase="false" id="attr"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.nist.gov"' ignoreCase="false" id="uri"/> |
| <assertEquals actual="localName" expected='"local1"' ignoreCase="false" id="lname"/> |
| <assertEquals actual="prefix" expected='"emp"' ignoreCase="false" id="prefix"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/removeNamedItemNS01.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="removeNamedItemNS01"> |
| <metadata> |
| <title>removeNamedItemNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeNamedItemNS(namespaceURI,localName)" method for a |
| NamedNodeMap should remove a node specified by localName and namespaceURI. |
| Retrieve a list of elements with tag name "address". |
| Access the second element from the list and get its attributes. |
| Try to remove the attribute node with local name "domestic" |
| and namespace uri "http://www.usa.com" with |
| method removeNamedItemNS(namespaceURI,localName). |
| Check to see if the node has been removed. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-1074577549"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"address"'/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="1"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <removeNamedItemNS var="removedNode" interface="NamedNodeMap" obj="attributes" namespaceURI='"http://www.usa.com"' localName='"domestic"'/> |
| <assertNotNull actual="removedNode" id="retval"/> |
| <getNamedItem obj="attributes" var="newAttr" name='"dmstc:domestic"'/> |
| <assertNull actual="newAttr" id="nodeRemoved"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/removeNamedItemNS02.xml.unknown |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="removeNamedItemNS02"> |
| <metadata> |
| <title>removeNamedItemNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeNamedItemNS(namespaceURI,localName)" method for a |
| NamedNodeMap should raise NOT_FOUND_ERR DOMException if |
| there is no node with the specified namespaceURI and localName in this map. |
| Retrieve a list of elements with tag name "address". |
| Access the second element from the list and get its attributes. |
| Try to remove an attribute node with local name "domest" |
| and namespace uri "http://www.usa.com" with |
| method removeNamedItemNS(namespaceURI,localName). |
| This should raise NOT_FOUND_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NOT_FOUND_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-removeNamedItemNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-removeNamedItemNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NOT_FOUND_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.usa.com""/> |
| <var name="localName" type="DOMString" value=""domest""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="1"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeNamedItemNS var="removedNode" interface="NamedNodeMap" obj="attributes" namespaceURI="namespaceURI" localName="localName"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/removeNamedItemNS03.xml.unknown |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="removeNamedItemNS03"> |
| <metadata> |
| <title>removeNamedItemNS03</title> |
| <creator>NIST</creator> |
| <description> |
| The "removeNamedItemNS(namespaceURI,localName)" method for a |
| NamedNodeMap should raise NO_MODIFICATION_ALLOWED_ERR DOMException if |
| this map is readonly. |
| Retrieve a list of "gender" elements. Get access to the THIRD element |
| which contains an ENTITY_REFERENCE child node. Try to remove the attribute |
| in the node's map with method removeNamedItemNS(namespaceURI,localName). |
| This should result in NO_MODIFICATION_ALLOWED_ERR |
| DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-removeNamedItemNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-removeNamedItemNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="namespaceURI" type="DOMString" value='"http://www.w3.org/2000/xmlns/"'/> |
| <var name="localName" type="DOMString" value=""local1""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="nList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="n2List" type="NodeList"/> |
| <var name="child2" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="removedNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""gender""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <childNodes obj="testAddress" var="nList"/> |
| <item interface="NodeList" obj="nList" var="child" index="0"/> |
| <nodeType var="nodeType" obj="child"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="child" name='"ent4"' obj="doc"/> |
| <assertNotNull actual="child" id="createdEntRefNotNull"/> |
| </if> |
| <childNodes obj="child" var="n2List"/> |
| <item interface="NodeList" obj="n2List" var="child2" index="0"/> |
| <assertNotNull actual="child2" id="notnull"/> |
| <attributes obj="child2" var="attributes"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeNamedItemNS var="removedNode" interface="NamedNodeMap" obj="attributes" namespaceURI="namespaceURI" localName="localName"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNS01.xml.unknown |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNS01"> |
| <metadata> |
| <title>setAttributeNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNS(namespaceURI,qualifiedName,Value)" method raises a |
| INVALID_CHARACTER_ERR DOMException if the specified |
| prefix contains an illegal character. |
| Attempt to add a new attribute on the first employee node. |
| An exception should be raised since the "qualifiedName" has an invalid |
| character. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-ElSetAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:qual?name""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""employee""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <setAttributeNS obj="testAddr" namespaceURI="namespaceURI" qualifiedName="qualifiedName" value=""newValue""/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNS02.xml.unknown |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNS02"> |
| <metadata> |
| <title>setAttributeNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNS(namespaceURI,qualifiedName,value)" method raises a |
| NAMESPACE_ERR DOMException if the specified |
| qualifiedName if malformed. |
| Attempt to add a new attribute on the second employee node. |
| An exception should be raised since the "qualifiedName" is malformed. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-ElSetAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""emp:employee""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <setAttributeNS obj="testAddr" namespaceURI="namespaceURI" qualifiedName="qualifiedName" value=""newValue""/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNS03.xml.unknown |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNS03"> |
| <metadata> |
| <title>setAttributeNS03</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNS(namespaceURI,qualifiedName,value)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Try to set an attribute |
| in the entity reference by executing the |
| "setAttributeNS(namespaceURI,qualifiedName,value)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-ElSetAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""www.xyz.com""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:local1""/> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="genList" type="NodeList"/> |
| <var name="gen" type="Node"/> |
| <var name="gList" type="NodeList"/> |
| <var name="genElement" type="Element"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <childNodes obj="gender" var="genList"/> |
| <item interface="NodeList" obj="genList" var="gen" index="0"/> |
| <nodeType var="nodeType" obj="gen"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="gen" name='"ent4"' obj="doc"/> |
| <assertNotNull actual="gen" id="createdEntRefNotNull"/> |
| </if> |
| <childNodes obj="gen" var="gList"/> |
| <item interface="NodeList" obj="gList" var="genElement" index="0"/> |
| <assertNotNull actual="genElement" id="notnull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setAttributeNS obj="genElement" namespaceURI="namespaceURI" qualifiedName="qualifiedName" value=""newValue""/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNS04.xml.unknown |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNS04"> |
| <metadata> |
| <title>setAttributeNS04</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNS(namespaceURI,qualifiedName,value)" method adds a new attribute. |
| If an attribute with the same local name and namespace URI is already present |
| on the element, its prefix is changed to be the prefix part of the "qualifiedName", |
| and its vale is changed to be the "value" paramter. |
| null value if no previously existing Attr node with the |
| same name was replaced. |
| Add a new attribute to the "emp:address" element. |
| Check to see if the new attribute has been successfully added to the document |
| by getting the attributes value, namespace URI, local Name and prefix. |
| The prefix will be changed to the prefix part of the "qualifiedName" |
| and its value changed to the "value" parameter. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="resultAttr" type="DOMString"/> |
| <var name="resultNamespaceURI" type="DOMString"/> |
| <var name="resultLocalName" type="DOMString"/> |
| <var name="resultPrefix" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""emp:address""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <setAttributeNS obj="testAddr" namespaceURI='"http://www.nist.gov"' qualifiedName='"newprefix:zone"' value='"newValue"'/> |
| <getAttributeNodeNS obj="testAddr" var="addrAttr" namespaceURI='"http://www.nist.gov"' localName='"zone"'/> |
| <getAttributeNS obj="testAddr" var="resultAttr" namespaceURI='"http://www.nist.gov"' localName='"zone"'/> |
| <assertEquals actual="resultAttr" expected='"newValue"' id="attrValue" ignoreCase="false"/> |
| <namespaceURI obj="addrAttr" var="resultNamespaceURI"/> |
| <assertEquals actual="resultNamespaceURI" expected='"http://www.nist.gov"' id="nsuri" ignoreCase="false"/> |
| <localName obj="addrAttr" var="resultLocalName"/> |
| <assertEquals actual="resultLocalName" expected='"zone"' id="lname" ignoreCase="false"/> |
| <prefix obj="addrAttr" var="resultPrefix"/> |
| <assertEquals actual="resultPrefix" expected='"newprefix"' id="prefix" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNS05.xml.unknown |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNS05"> |
| <metadata> |
| <title>setAttributeNS05</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNS(namespaceURI,qualifiedName,value)" method adds a new attribute. |
| If an attribute with the same local name and namespace URI is already present |
| on the element, its prefix is changed to be the prefix part of the "qualifiedName", |
| and its vale is changed to be the "value" paramter. |
| null value if no previously existing Attr node with the |
| same name was replaced. |
| Add a new attribute to the "emp:address" element. |
| Check to see if the new attribute has been successfully added to the document. |
| The new attribute "<newValue>" contains markup and therefore is escaped |
| by the implementation. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElGetAttrNS"/> |
| </metadata> |
| <var name="localName" type="DOMString" value=""newAttr""/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.newattr.com""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:newAttr""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="resultAttr" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""emp:address""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <setAttributeNS obj="testAddr" namespaceURI="namespaceURI" qualifiedName="qualifiedName" value=""<newValue>""/> |
| <getAttributeNS obj="testAddr" var="resultAttr" namespaceURI="namespaceURI" localName="localName"/> |
| <assertEquals actual="resultAttr" expected=""<newValue>"" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNS06.xml.unknown |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNS06"> |
| <metadata> |
| <title>setAttributeNS06</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNS(namespaceURI,localName,value)" method raises a |
| NAMESPACE_ERR DOMException if the "qualifiedName" has a |
| prefix of "xml" and the namespaceURI is different from |
| http://www.w3.org/XML/1998/namespace. |
| Attempt to add an attribute with a prefix of "xml" as the on the first employee node. |
| An exception should be raised since the namespaceURI of this node is not |
| http://www.w3.org/XML/1998/namespace. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-ElSetAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="qualifiedName" type="DOMString" value=""xml:qualifiedName""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""employee""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <setAttributeNS obj="testAddr" namespaceURI="namespaceURI" qualifiedName="qualifiedName" value=""newValue""/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNS07.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNS07"> |
| <metadata> |
| <title>setAttributeNS07</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNS(namespaceURI,localName,value)" method raises a |
| NAMESPACE_ERR DOMException if the "qualifiedName" has a |
| value of "xmlns" and the namespaceURI is different from |
| http://www.w3.org/2000/xmlns. |
| Attempt to add an attribute with a "qualifiedName" of "xmlns" as the |
| on the first employee node. |
| An exception should be raised since the namespaceURI of this node is not |
| http://www.w3.org/2000/xmlns. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NAMESPACE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-ElSetAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NAMESPACE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="qualifiedName" type="DOMString" value=""xmlns""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""employee""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <setAttributeNS obj="testAddr" namespaceURI="namespaceURI" qualifiedName="qualifiedName" value=""newValue""/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNS09.xml.unknown |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNS09"> |
| <metadata> |
| <title>setAttributeNS09</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNS(namespaceURI,qualifiedName,value)" method adds a new attribute. |
| If an attribute with the same local name and namespace URI is already present |
| on the element, its prefix is changed to be the prefix part of the "qualifiedName", |
| and its vale is changed to be the "value" paramter. |
| null value if no previously existing Attr node with the |
| same name was replaced. |
| Add a new attribute to the "emp:address" element. |
| Check to see if the new attribute has been successfully added to the document |
| by getting the attributes value, namespace URI, local Name and prefix. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| </metadata> |
| <var name="localName" type="DOMString" value=""newAttr""/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.newattr.com""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:newAttr""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <var name="addrAttr" type="Attr"/> |
| <var name="resultAttr" type="DOMString"/> |
| <var name="resultNamespaceURI" type="DOMString"/> |
| <var name="resultLocalName" type="DOMString"/> |
| <var name="resultPrefix" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""emp:address""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <setAttributeNS obj="testAddr" namespaceURI="namespaceURI" qualifiedName="qualifiedName" value=""newValue""/> |
| <getAttributeNodeNS obj="testAddr" var="addrAttr" namespaceURI="namespaceURI" localName="localName"/> |
| <getAttributeNS obj="testAddr" var="resultAttr" namespaceURI="namespaceURI" localName="localName"/> |
| <assertEquals actual="resultAttr" expected='"newValue"' id="attrValue" ignoreCase="false"/> |
| <namespaceURI obj="addrAttr" var="resultNamespaceURI"/> |
| <assertEquals actual="resultNamespaceURI" expected='"http://www.newattr.com"' id="nsuri" ignoreCase="false"/> |
| <localName obj="addrAttr" var="resultLocalName"/> |
| <assertEquals actual="resultLocalName" expected='"newAttr"' id="lname" ignoreCase="false"/> |
| <prefix obj="addrAttr" var="resultPrefix"/> |
| <assertEquals actual="resultPrefix" expected='"emp"' id="prefix" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNS10.xml.unknown |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNS10"> |
| <metadata> |
| <title>setAttributeNS10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Element.setAttributeNS with an empty qualified name should cause an INVALID_CHARACTER_ERR. |
| </description> |
| <date qualifier="created">2004-03-09</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAttrNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-ElSetAttrNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INVALID_CHARACTER_ERR'])"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=525"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value='"http://www.example.gov"'/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"em"'/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertDOMException id="throw_INVALID_CHARACTER_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <setAttributeNS obj="testAddr" namespaceURI="namespaceURI" qualifiedName='""' value='"newValue"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNodeNS01.xml.unknown |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNodeNS01"> |
| <metadata> |
| <title>setAttributeNodeNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNode(newAttr)" method raises an |
| "INUSE_ATTRIBUTE_ERR DOMException if the "newAttr" |
| is already an attribute of another element. |
| Retrieve the first emp:address and append |
| a newly created element. The "createAttributeNS(namespaceURI,qualifiedName)" |
| and "setAttributeNodeNS(newAttr)" methods are invoked |
| to create and add a new attribute to the newly created |
| Element. The "setAttributeNodeNS(newAttr)" method is |
| once again called to add the new attribute causing an |
| exception to be raised since the attribute is already |
| an attribute of another element. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-ElSetAtNodeNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INUSE_ATTRIBUTE_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.newattr.com""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:newAttr""/> |
| <var name="doc" type="Document"/> |
| <var name="newElement" type="Element"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="setAttr1" type="Attr"/> |
| <var name="setAttr2" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""emp:address""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <createElement obj="doc" var="newElement" tagName=""newElement""/> |
| <appendChild var="appendedChild" obj="testAddr" newChild="newElement"/> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <setAttributeNodeNS var="setAttr1" obj="newElement" newAttr="newAttr"/> |
| <assertDOMException id="throw_INUSE_ATTRIBUTE_ERR"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setAttributeNodeNS var="setAttr2" obj="testAddr" newAttr="newAttr"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNodeNS02.xml.unknown |
|---|
| 0,0 → 1,69 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNodeNS02"> |
| <metadata> |
| <title>setAttributeNodeNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNodeNS(namespaceURI,qualifiedName,value)" method for an attribute causes the |
| DOMException NO_MODIFICATION_ALLOWED_ERR to be raised |
| if the node is readonly. |
| Obtain the children of the THIRD "gender" element. The elements |
| content is an entity reference. Try to set an attribute |
| in the entity reference by executing the |
| "setAttributeNodeNS(newAttr)" method. |
| This causes a NO_MODIFICATION_ALLOWED_ERR DOMException to be thrown. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-ElSetAtNodeNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="genderList" type="NodeList"/> |
| <var name="gender" type="Node"/> |
| <var name="genList" type="NodeList"/> |
| <var name="gen" type="Node"/> |
| <var name="gList" type="NodeList"/> |
| <var name="genElement" type="Element"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="setAttr1" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <if> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="genderList" tagname=""gender""/> |
| <item interface="NodeList" obj="genderList" var="gender" index="2"/> |
| <childNodes obj="gender" var="genList"/> |
| <item interface="NodeList" obj="genList" var="gen" index="0"/> |
| <else> |
| <createEntityReference var="gen" name='"ent4"' obj="doc"/> |
| </else> |
| </if> |
| <childNodes obj="gen" var="gList"/> |
| <item interface="NodeList" obj="gList" var="genElement" index="0"/> |
| <assertNotNull actual="genElement" id="notnull"/> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI='"www.xyz.com"' qualifiedName='"emp:local1"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setAttributeNodeNS var="setAttr1" obj="genElement" newAttr="newAttr"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNodeNS03.xml.unknown |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNodeNS03"> |
| <metadata> |
| <title>setAttributeNodeNS03</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNodeNS(newAttr)" adds a new attribute. |
| If an attribute with that local name and that namespaceURI is already |
| present in the element, it is replaced by the new one. |
| Retrieve the first emp:address element and add a new attribute |
| to the element. Since an attribute with the same local name |
| and namespaceURI as the newly created attribute does not exist |
| the value "null" is returned. |
| This test uses the "createAttributeNS(namespaceURI,localName) |
| method from the Document interface to create the new attribute to add. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.newattr.com""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:newAttr""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="newAddrAttr" type="Attr"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""emp:address""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <setAttributeNodeNS obj="testAddr" newAttr="newAttr" var="newAddrAttr"/> |
| <assertNull actual="newAddrAttr" id="throw_Null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNodeNS04.xml.unknown |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNodeNS04"> |
| <metadata> |
| <title>setAttributeNodeNS04</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNodeNS(newAttr)" adds a new attribute. |
| If an attribute with that local name and that namespaceURI is already |
| present in the element, it is replaced by the new one. |
| Retrieve the first emp:address element and add a new attribute |
| to the element. Since an attribute with the same local name |
| and namespaceURI already exists, it is replaced by the new one and |
| returns the replaced "Attr" node. |
| This test uses the "createAttributeNS(namespaceURI,localName) |
| method from the Document interface to create the new attribute to add. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-F68D095"/> |
| </metadata> |
| <!-- test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="newAddrAttr" type="Attr"/> |
| <var name="newName" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"emp:address"'/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertNotNull actual="testAddr" id="empAddrNotNull"/> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI='"http://www.nist.gov"' qualifiedName='"xxx:domestic"'/> |
| <setAttributeNodeNS obj="testAddr" newAttr="newAttr" var="newAddrAttr"/> |
| <nodeName obj="newAddrAttr" var="newName"/> |
| <assertEquals actual="newName" expected='"emp:domestic"' id="nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setAttributeNodeNS05.xml.unknown |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setAttributeNodeNS05"> |
| <metadata> |
| <title>setAttributeNodeNS05</title> |
| <creator>NIST</creator> |
| <description> |
| The "setAttributeNodeNS(newAttr)" method raises an |
| "WRONG_DOCUMENT_ERR DOMException if the "newAttr" |
| was created from a different document than the one that |
| created this document. |
| Retrieve the first emp:address and attempt to set a new |
| attribute node. The new |
| attribute was created from a document other than the |
| one that created this element, therefore a |
| WRONG_DOCUMENT_ERR DOMException should be raised. |
| This test uses the "createAttributeNS(newAttr)" method |
| from the Document interface. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-ElSetAtNodeNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='WRONG_DOCUMENT_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.newattr.com""/> |
| <var name="qualifiedName" type="DOMString" value=""emp:newAttr""/> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddr" type="Node"/> |
| <var name="setAttr1" type="Attr"/> |
| <load var="doc1" href="staffNS" willBeModified="true"/> |
| <load var="doc2" href="staffNS" willBeModified="true"/> |
| <createAttributeNS obj="doc2" var="newAttr" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <getElementsByTagName interface="Document" obj="doc1" var="elementList" tagname=""emp:address""/> |
| <item interface="NodeList" obj="elementList" var="testAddr" index="0"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <setAttributeNodeNS var="setAttr1" obj="testAddr" newAttr="newAttr"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setNamedItemNS01.xml.unknown |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setNamedItemNS01"> |
| <metadata> |
| <title>setNamedItemNS01</title> |
| <creator>NIST</creator> |
| <description> |
| The "setNamedItemNS(arg)" method for a |
| NamedNodeMap should raise INUSE_ATTRIBUTE_ERR DOMException if |
| arg is an Attr that is already an attribute of another Element object. |
| Retrieve an attr node from the third "address" element whose local name |
| is "domestic" and namespaceURI is "http://www.netzero.com". |
| Invoke method setNamedItemNS(arg) on the map of the first "address" element with |
| arg being the attr node from above. Method should raise |
| INUSE_ATTRIBUTE_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='INUSE_ATTRIBUTE_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-setNamedItemNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INUSE_ATTRIBUTE_ERR'])"/> |
| </metadata> |
| <!-- this test requires namespace awareness --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="anotherElement" type="Node"/> |
| <var name="anotherMap" type="NamedNodeMap"/> |
| <var name="arg" type="Node"/> |
| <var name="testAddress" type="Node"/> |
| <var name="map" type="NamedNodeMap"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname='"address"'/> |
| <item interface="NodeList" obj="elementList" var="anotherElement" index="2"/> |
| <attributes obj="anotherElement" var="anotherMap"/> |
| <getNamedItemNS obj="anotherMap" var="arg" namespaceURI='"http://www.netzero.com"' localName='"domestic"'/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="0"/> |
| <attributes obj="testAddress" var="map"/> |
| <assertDOMException id="throw_INUSE_ATTRIBUTE_ERR"> |
| <INUSE_ATTRIBUTE_ERR> |
| <setNamedItemNS var="setNode" interface="NamedNodeMap" obj="map" arg="arg"/> |
| </INUSE_ATTRIBUTE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setNamedItemNS02.xml.unknown |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setNamedItemNS02"> |
| <metadata> |
| <title>setNamedItemNS02</title> |
| <creator>NIST</creator> |
| <description> |
| The "setNamedItemNS(arg)" method for a |
| NamedNodeMap should raise WRONG_DOCUMENT_ERR DOMException if arg was |
| created from a different document than the one that created this map. |
| Create an attr node in a different document with qualifiedName equals |
| "dmstc:domestic" and namespaceURI is "http://www.usa.com". |
| Access the namednodemap of the first "address" element in this document. |
| Invoke method setNamedItemNS(arg) with arg being the attr node from above. |
| Method should raise WRONG_DOCUMENT_ERR DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='WRONG_DOCUMENT_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-setNamedItemNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='WRONG_DOCUMENT_ERR'])"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.usa.com""/> |
| <var name="qualifiedName" type="DOMString" value=""dmstc:domestic""/> |
| <var name="doc" type="Document"/> |
| <var name="anotherDoc" type="Document"/> |
| <var name="arg" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <load var="anotherDoc" href="staffNS" willBeModified="true"/> |
| <createAttributeNS obj="anotherDoc" var="arg" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <nodeValue obj="arg" value=""Maybe""/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="0"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <setNamedItemNS var="setNode" interface="NamedNodeMap" obj="attributes" arg="arg"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setNamedItemNS03.xml.unknown |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setNamedItemNS03"> |
| <metadata> |
| <title>setNamedItemNS03</title> |
| <creator>NIST</creator> |
| <description> |
| The "setNamedItemNS(arg)" method for a |
| NamedNodeMap should add a node using its namespaceURI and localName given that |
| there is no existing node with the same namespaceURI and localName in the map. |
| Create an attr node with namespaceURI "http://www.nist.gov",qualifiedName |
| "prefix:newAttr" and value "newValue". |
| Invoke method setNamedItemNS(arg) on the map of the first "address" |
| element where arg is identified by the namespaceURI and qualifiedName |
| from above. Method should return the newly added attr node. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-F68D080"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.nist.gov""/> |
| <var name="qualifiedName" type="DOMString" value=""prefix:newAttr""/> |
| <var name="doc" type="Document"/> |
| <var name="arg" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="retnode" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <var name="setNode" type="Node"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createAttributeNS obj="doc" var="arg" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <nodeValue obj="arg" value=""newValue""/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="0"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <setNamedItemNS var="setNode" interface="NamedNodeMap" obj="attributes" arg="arg"/> |
| <getNamedItemNS obj="attributes" var="retnode" namespaceURI="namespaceURI" localName=""newAttr""/> |
| <nodeValue obj="retnode" var="value"/> |
| <assertEquals actual="value" expected=""newValue"" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setNamedItemNS04.xml.unknown |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setNamedItemNS04"> |
| <metadata> |
| <title>setNamedItemNS04</title> |
| <creator>NIST</creator> |
| <description> |
| The "setNamedItemNS(arg)" method for a |
| NamedNodeMap should raise NO_MODIFICATION_ALLOWED_ERR DOMException if |
| this map is readonly. |
| Retrieve a list of "gender" elements. Get access to the THIRD element |
| which contains an ENTITY_REFERENCE child node. Get access to the node's |
| map. Try to add an attribute node specified by arg with |
| method setNamedItemNS(arg). This should result in NO_MODIFICATION_ALLOWED_ERR |
| DOMException. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-258A00AF')/constant[@name='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-setNamedItemNS"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#xpointer(id('ID-setNamedItemNS')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='NO_MODIFICATION_ALLOWED_ERR'])"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="namespaceURI" type="DOMString" value=""http://www.w3.org/2000/xmlns/""/> |
| <var name="localName" type="DOMString" value=""local1""/> |
| <var name="doc" type="Document"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="nList" type="NodeList"/> |
| <var name="child" type="Node"/> |
| <var name="n2List" type="NodeList"/> |
| <var name="child2" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="arg" type="Node"/> |
| <var name="setNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""gender""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="2"/> |
| <childNodes obj="testAddress" var="nList"/> |
| <item interface="NodeList" obj="nList" var="child" index="0"/> |
| <nodeType var="nodeType" obj="child"/> |
| <if><equals actual="nodeType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="child" name='"ent4"' obj="doc"/> |
| <assertNotNull actual="child" id="createdEntRefNotNull"/> |
| </if> |
| <childNodes obj="child" var="n2List"/> |
| <item interface="NodeList" obj="n2List" var="child2" index="0"/> |
| <assertNotNull actual="child2" id="notnull"/> |
| <attributes obj="child2" var="attributes"/> |
| <getNamedItemNS obj="attributes" var="arg" namespaceURI="namespaceURI" localName="localName"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setNamedItemNS var="setNode" interface="NamedNodeMap" obj="attributes" arg="arg"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/setNamedItemNS05.xml.unknown |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="setNamedItemNS05"> |
| <metadata> |
| <title>setNamedItemNS05</title> |
| <creator>NIST</creator> |
| <description> |
| The "setNamedItemNS(arg)" method for a |
| NamedNodeMap should replace an existing node n1 found in the map with arg if n1 |
| has the same namespaceURI and localName as arg and return n1. |
| Create an attribute node in with namespaceURI "http://www.usa.com" |
| and qualifiedName "dmstc:domestic" whose value is "newVal". |
| Invoke method setNamedItemNS(arg) on the map of the first "address" |
| element. Method should return the old attribute node identified |
| by namespaceURI and qualifiedName from above,whose value is "Yes". |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-ElSetAtNodeNS"/> |
| </metadata> |
| <var name="namespaceURI" type="DOMString" value=""http://www.usa.com""/> |
| <var name="qualifiedName" type="DOMString" value=""dmstc:domestic""/> |
| <var name="doc" type="Document"/> |
| <var name="arg" type="Node"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="testAddress" type="Node"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="retnode" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="staffNS" willBeModified="true"/> |
| <createAttributeNS obj="doc" var="arg" namespaceURI="namespaceURI" qualifiedName="qualifiedName"/> |
| <nodeValue obj="arg" value=""newValue""/> |
| <getElementsByTagName interface="Document" obj="doc" var="elementList" tagname=""address""/> |
| <item interface="NodeList" obj="elementList" var="testAddress" index="0"/> |
| <attributes obj="testAddress" var="attributes"/> |
| <setNamedItemNS interface="NamedNodeMap" obj="attributes" var="retnode" arg="arg"/> |
| <nodeValue obj="retnode" var="value"/> |
| <assertEquals actual="value" expected=""Yes"" id="throw_Equals" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/core/systemId01.xml.unknown |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="systemId01"> |
| <metadata> |
| <title>systemId01</title> |
| <creator>NIST</creator> |
| <description> |
| The "getSystemId()" method of a documenttype node contains |
| the system identifier associated with the external subset. |
| Retrieve the documenttype. |
| Apply the "getSystemId()" method. The string "staffNS.dtd" should be |
| returned. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-08-17</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-Core-DocType-systemId"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="systemId" type="DOMString"/> |
| <var name="index" type="int"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <doctype obj="doc" var="docType"/> |
| <systemId interface="DocumentType" obj="docType" var="systemId"/> |
| <assertURIEquals actual="systemId" file='"staffNS.dtd"' id="systemId"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/.cvsignore |
|---|
| 0,0 → 1,2 |
| dom2.dtd |
| dom2.xsd |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/CVS/Entries |
|---|
| 0,0 → 1,30 |
| D/files//// |
| /.cvsignore/1.2/Fri Apr 3 02:47:56 2009// |
| /DocumentEventCast01.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /EventTargetCast01.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /alltests.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /createEvent01.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /createEvent02.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /createEvent03.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /createEvent04.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /createEvent05.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent01.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent02.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent03.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent04.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent05.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent06.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent07.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent08.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent09.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent10.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent11.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent12.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /dispatchEvent13.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /initEvent01.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /initEvent02.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /initEvent03.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /initEvent04.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /initEvent05.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /initEvent06.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /metadata.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level2/events |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/CVS/Template |
|---|
| --- test/testcases/tests/level2/events/DocumentEventCast01.xml (nonexistent) |
| +++ test/testcases/tests/level2/events/DocumentEventCast01.xml (revision 4364) |
| @@ -0,0 +1,33 @@ |
| +<?xml version="1.0" encoding="UTF-8"?> |
| +<?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| +<!-- |
| + |
| +Copyright (c) 2001 World Wide Web Consortium, |
| +(Massachusetts Institute of Technology, Institut National de |
| +Recherche en Informatique et en Automatique, Keio University). All |
| +Rights Reserved. This program is distributed under the W3C's Software |
| +Intellectual Property License. This program is distributed in the |
| +hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| +PURPOSE. |
| + |
| +See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| + |
| +--> |
| +<!DOCTYPE test SYSTEM "dom2.dtd"> |
| +<test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="DocumentEventCast01"> |
| +<metadata> |
| +<title>DocumentEventCast01</title> |
| +<creator>Curt Arnold</creator> |
| +<description> |
| +A document is created using implementation.createDocument and |
| +cast to a DocumentEvent interface. |
| +</description> |
| +<date qualifier="created">2002-04-21</date> |
| +<subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-DocumentEvent"/> |
| +</metadata> |
| +<var name="doc" type="Document"/> |
| +<var name="docEvent" type="DocumentEvent"/> |
| +<load var="doc" href="hc_staff" willBeModified="true"/> |
| +<assign var="docEvent" value="doc"/> |
| +</test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/EventTargetCast01.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="EventTargetCast01"> |
| <metadata> |
| <title>EventTargetCast01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| A document is created using implementation.createDocument and |
| cast to a EventTarget interface. |
| </description> |
| <date qualifier="created">2002-04-21</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <assign var="target" value="doc"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/alltests.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE suite SYSTEM "dom2.dtd"> |
| <suite xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="alltests"> |
| <metadata> |
| <title>DOM Level 2 Events Test Suite</title> |
| <creator>DOM Test Suite Project</creator> |
| </metadata> |
| <suite.member href="DocumentEventCast01.xml"/> |
| <suite.member href="EventTargetCast01.xml"/> |
| <suite.member href="createEvent01.xml"/> |
| <suite.member href="createEvent02.xml"/> |
| <suite.member href="createEvent03.xml"/> |
| <suite.member href="createEvent04.xml"/> |
| <suite.member href="createEvent05.xml"/> |
| <suite.member href="dispatchEvent01.xml"/> |
| <suite.member href="dispatchEvent02.xml"/> |
| <suite.member href="dispatchEvent03.xml"/> |
| <suite.member href="dispatchEvent04.xml"/> |
| <suite.member href="dispatchEvent05.xml"/> |
| <suite.member href="dispatchEvent06.xml"/> |
| <suite.member href="dispatchEvent07.xml"/> |
| <suite.member href="dispatchEvent08.xml"/> |
| <suite.member href="dispatchEvent09.xml"/> |
| <suite.member href="dispatchEvent10.xml"/> |
| <suite.member href="dispatchEvent11.xml"/> |
| <suite.member href="dispatchEvent12.xml"/> |
| <suite.member href="dispatchEvent13.xml"/> |
| <suite.member href="initEvent01.xml"/> |
| <suite.member href="initEvent02.xml"/> |
| <suite.member href="initEvent03.xml"/> |
| <suite.member href="initEvent04.xml"/> |
| <suite.member href="initEvent05.xml"/> |
| <suite.member href="initEvent06.xml"/> |
| </suite> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/createEvent01.xml |
|---|
| 0,0 → 1,34 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createEvent01"> |
| <metadata> |
| <title>createEvent01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An object implementing the Event interface is created by using |
| DocumentEvent.createEvent method with eventType equals "Events". |
| </description> |
| <date qualifier="created">2002-04-21</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-DocumentEvent-createEvent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="event" type="Event"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"Events"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/createEvent02.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createEvent02"> |
| <metadata> |
| <title>createEvent02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An object implementing the Event interface is created by using |
| DocumentEvent.createEvent method with eventType equals "MutationEvents". |
| Only applicable if implementation supports MutationEvents. |
| </description> |
| <date qualifier="created">2002-04-21</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-DocumentEvent-createEvent"/> |
| </metadata> |
| <hasFeature feature='"MutationEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="event" type="MutationEvent"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"MutationEvents"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/createEvent03.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createEvent03"> |
| <metadata> |
| <title>createEvent03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An object implementing the Event interface is created by using |
| DocumentEvent.createEvent method with eventType equals "UIEvents". |
| Only applicable if implementation supports the "UIEvents" feature. |
| </description> |
| <date qualifier="created">2002-04-21</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-DocumentEvent-createEvent"/> |
| </metadata> |
| <hasFeature feature='"UIEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="event" type="UIEvent"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"UIEvents"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/createEvent04.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createEvent04"> |
| <metadata> |
| <title>createEvent04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An object implementing the Event interface is created by using |
| DocumentEvent.createEvent method with eventType equals "UIEvents". |
| Only applicable if implementation supports the "UIEvents" feature. |
| </description> |
| <date qualifier="created">2002-04-21</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-DocumentEvent-createEvent"/> |
| </metadata> |
| <hasFeature feature='"MouseEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="event" type="MouseEvent"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"MouseEvents"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/createEvent05.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="createEvent05"> |
| <metadata> |
| <title>createEvent05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An object implementing the Event interface is created by using |
| DocumentEvent.createEvent method with eventType equals "HTMLEvents". |
| Only applicable if implementation supports the "HTMLEvents" feature. |
| </description> |
| <date qualifier="created">2002-04-21</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-DocumentEvent-createEvent"/> |
| </metadata> |
| <hasFeature feature='"HTMLEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="event" type="Event"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"HTMLEvents"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent01.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent01"> |
| <metadata> |
| <title>dispatchEvent01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| A null reference is passed to EventTarget.dispatchEvent(), should raise implementation |
| or platform exception. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-17189187"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event" isNull="true"/> |
| <var name="preventDefault" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <assertImplementationException id="throw_ImplException"> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| </assertImplementationException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent02.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent02"> |
| <metadata> |
| <title>dispatchEvent02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An created but not initialized event is passed to EventTarget.dispatchEvent(). Should raise |
| UNSPECIFIED_EVENT_TYPE_ERR EventException. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="evt" obj="doc" eventType='"Events"'/> |
| <assertEventException id="throw_UNSPECIFIED_EVENT_TYPE_ERR"> |
| <UNSPECIFIED_EVENT_TYPE_ERR> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| </UNSPECIFIED_EVENT_TYPE_ERR> |
| </assertEventException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent03"> |
| <metadata> |
| <title>dispatchEvent03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An created but not initialized event is passed to EventTarget.dispatchEvent(). Should raise |
| UNSPECIFIED_EVENT_TYPE_ERR EventException. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <hasFeature feature='"MutationEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="evt" obj="doc" eventType='"MutationEvents"'/> |
| <assertEventException id="throw_UNSPECIFIED_EVENT_TYPE_ERR"> |
| <UNSPECIFIED_EVENT_TYPE_ERR> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| </UNSPECIFIED_EVENT_TYPE_ERR> |
| </assertEventException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent04.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent04"> |
| <metadata> |
| <title>dispatchEvent04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An created but not initialized event is passed to EventTarget.dispatchEvent(). Should raise |
| UNSPECIFIED_EVENT_TYPE_ERR EventException. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <hasFeature feature='"UIEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="evt" obj="doc" eventType='"UIEvents"'/> |
| <assertEventException id="throw_UNSPECIFIED_EVENT_TYPE_ERR"> |
| <UNSPECIFIED_EVENT_TYPE_ERR> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| </UNSPECIFIED_EVENT_TYPE_ERR> |
| </assertEventException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent05.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent05"> |
| <metadata> |
| <title>dispatchEvent05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An created but not initialized event is passed to EventTarget.dispatchEvent(). Should raise |
| UNSPECIFIED_EVENT_TYPE_ERR EventException. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <hasFeature feature='"MouseEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="evt" obj="doc" eventType='"MouseEvents"'/> |
| <assertEventException id="throw_UNSPECIFIED_EVENT_TYPE_ERR"> |
| <UNSPECIFIED_EVENT_TYPE_ERR> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| </UNSPECIFIED_EVENT_TYPE_ERR> |
| </assertEventException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent06.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent06"> |
| <metadata> |
| <title>dispatchEvent06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An created but not initialized event is passed to EventTarget.dispatchEvent(). Should raise |
| UNSPECIFIED_EVENT_TYPE_ERR EventException. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <hasFeature feature='"HTMLEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="evt" obj="doc" eventType='"HTMLEvents"'/> |
| <assertEventException id="throw_UNSPECIFIED_EVENT_TYPE_ERR"> |
| <UNSPECIFIED_EVENT_TYPE_ERR> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| </UNSPECIFIED_EVENT_TYPE_ERR> |
| </assertEventException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent07.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent07"> |
| <metadata> |
| <title>dispatchEvent07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An Event initialized with a empty name is passed to EventTarget.dispatchEvent(). Should raise |
| UNSPECIFIED_EVENT_TYPE_ERR EventException. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="evt" obj="doc" eventType='"Events"'/> |
| <initEvent obj="evt" eventTypeArg='""' canBubbleArg="false" cancelableArg="false"/> |
| <assertEventException id="throw_UNSPECIFIED_EVENT_TYPE_ERR"> |
| <UNSPECIFIED_EVENT_TYPE_ERR> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| </UNSPECIFIED_EVENT_TYPE_ERR> |
| </assertEventException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent08.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent08"> |
| <metadata> |
| <title>dispatchEvent08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An EventListener registered on the target node with capture false, should |
| recieve any event fired on that node. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <var name="monitor" type="EventMonitor"/> |
| <var name="atEvents" type="List"/> |
| <var name="bubbledEvents" type="List"/> |
| <var name="capturedEvents" type="List"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <addEventListener obj="doc" type='"foo"' listener="monitor" useCapture="false"/> |
| <createEvent var="evt" obj="doc" eventType='"Events"'/> |
| <initEvent obj="evt" eventTypeArg='"foo"' canBubbleArg="true" cancelableArg="false"/> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| <atEvents obj="monitor" var="atEvents"/> |
| <assertSize id="atCount" collection="atEvents" size="1"/> |
| <bubbledEvents obj="monitor" var="bubbledEvents"/> |
| <assertSize id="bubbleCount" collection="bubbledEvents" size="0"/> |
| <capturedEvents obj="monitor" var="capturedEvents"/> |
| <assertSize id="captureCount" collection="capturedEvents" size="0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent09.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent09"> |
| <metadata> |
| <title>dispatchEvent09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An event is dispatched to the document with a capture listener attached. |
| A capturing EventListener will not be triggered by events dispatched directly to the EventTarget upon which it is registered. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <var name="monitor" type="EventMonitor"/> |
| <var name="atEvents" type="List"/> |
| <var name="bubbledEvents" type="List"/> |
| <var name="capturedEvents" type="List"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <addEventListener obj="doc" type='"foo"' listener="monitor" useCapture="true"/> |
| <createEvent var="evt" obj="doc" eventType='"Events"'/> |
| <initEvent obj="evt" eventTypeArg='"foo"' canBubbleArg="true" cancelableArg="false"/> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| <atEvents obj="monitor" var="atEvents"/> |
| <assertSize id="atCount" collection="atEvents" size="0"/> |
| <bubbledEvents obj="monitor" var="bubbledEvents"/> |
| <assertSize id="bubbleCount" collection="bubbledEvents" size="0"/> |
| <capturedEvents obj="monitor" var="capturedEvents"/> |
| <assertSize id="captureCount" collection="capturedEvents" size="0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent10.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent10"> |
| <metadata> |
| <title>dispatchEvent10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The same monitor is registered twice and an event is dispatched. The monitor should |
| recieve only one handleEvent call. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <var name="monitor" type="EventMonitor"/> |
| <var name="atEvents" type="List"/> |
| <var name="bubbledEvents" type="List"/> |
| <var name="capturedEvents" type="List"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <addEventListener obj="doc" type='"foo"' listener="monitor" useCapture="false"/> |
| <addEventListener obj="doc" type='"foo"' listener="monitor" useCapture="false"/> |
| <createEvent var="evt" obj="doc" eventType='"Events"'/> |
| <initEvent obj="evt" eventTypeArg='"foo"' canBubbleArg="true" cancelableArg="false"/> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| <atEvents obj="monitor" var="atEvents"/> |
| <assertSize id="atCount" collection="atEvents" size="1"/> |
| <bubbledEvents obj="monitor" var="bubbledEvents"/> |
| <assertSize id="bubbleCount" collection="bubbledEvents" size="0"/> |
| <capturedEvents obj="monitor" var="capturedEvents"/> |
| <assertSize id="captureCount" collection="capturedEvents" size="0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent11.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent11"> |
| <metadata> |
| <title>dispatchEvent11</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The same monitor is registered twice, removed once, and an event is dispatched. |
| The monitor should recieve only no handleEvent calls. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <var name="monitor" type="EventMonitor"/> |
| <var name="events" type="List"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <addEventListener obj="doc" type='"foo"' listener="monitor" useCapture="false"/> |
| <addEventListener obj="doc" type='"foo"' listener="monitor" useCapture="false"/> |
| <removeEventListener obj="doc" type='"foo"' listener="monitor" useCapture="false"/> |
| <createEvent var="evt" obj="doc" eventType='"Events"'/> |
| <initEvent obj="evt" eventTypeArg='"foo"' canBubbleArg="true" cancelableArg="false"/> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| <allEvents obj="monitor" var="events"/> |
| <assertSize id="eventCount" collection="events" size="0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent12.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2005 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent12"> |
| <metadata> |
| <title>dispatchEvent12</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| A monitor is added, multiple calls to removeEventListener |
| are mde with similar but not identical arguments, and an event is dispatched. |
| The monitor should recieve handleEvent calls. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <var name="monitor" type="EventMonitor"/> |
| <var name="other" type="EventListener"> |
| <handleEvent/> |
| </var> |
| <var name="events" type="List"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <addEventListener obj="doc" type='"foo"' listener="monitor" useCapture="false"/> |
| <removeEventListener obj="doc" type='"foo"' listener="monitor" useCapture="true"/> |
| <removeEventListener obj="doc" type='"food"' listener="monitor" useCapture="false"/> |
| <removeEventListener obj="doc" type='"foo"' listener="other" useCapture="false"/> |
| <createEvent var="evt" obj="doc" eventType='"Events"'/> |
| <initEvent obj="evt" eventTypeArg='"foo"' canBubbleArg="true" cancelableArg="false"/> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| <allEvents obj="monitor" var="events"/> |
| <assertSize id="eventCount" collection="events" size="1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/dispatchEvent13.xml |
|---|
| 0,0 → 1,84 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="dispatchEvent13"> |
| <metadata> |
| <title>dispatchEvent13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Two listeners are registered on the same target, each of which will remove both itself and |
| the other on the first event. Only one should see the event since event listeners |
| can never be invoked after being removed. |
| </description> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-EventTarget-dispatchEvent"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#xpointer(id('Events-EventTarget-dispatchEvent')/raises/exception[@name='EventException']/descr/p[substring-before(.,':')='UNSPECIFIED_EVENT_TYPE_ERR'])"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="target" type="EventTarget"/> |
| <var name="evt" type="Event"/> |
| <var name="preventDefault" type="boolean"/> |
| <var name="listeners" type="List"/> |
| <var name="events" type="List"/> |
| <!-- definition of private class instance that implements EventListener --> |
| <var name="listener1" type="EventListener"> |
| <!-- instance scope variables, |
| value attributes are passed via constructor --> |
| <var name="events" type="List" value="events"/> |
| <var name="listeners" type="List" value="listeners"/> |
| <!-- implementation of handleEvent method |
| any parameters (in this case 'evt') are |
| predefined --> |
| <handleEvent> |
| <!-- method scope variables --> |
| <var name="target" type="EventTarget"/> |
| <var name="listener" type="EventListener"/> |
| <!-- add event to the collection --> |
| <append collection="events" item="evt"/> |
| <!-- remove this and the other listener --> |
| <currentTarget var="target" obj="evt"/> |
| <for-each collection="listeners" member="listener"> |
| <removeEventListener obj="target" type='"foo"' listener="listener" useCapture="false"/> |
| </for-each> |
| </handleEvent> |
| </var> |
| <!-- identical implementation of EventListener --> |
| <var name="listener2" type="EventListener"> |
| <var name="events" type="List" value="events"/> |
| <var name="listeners" type="List" value="listeners"/> |
| <handleEvent> |
| <var name="target" type="EventTarget"/> |
| <var name="listener" type="EventListener"/> |
| <!-- add event to the collection --> |
| <append collection="events" item="evt"/> |
| <!-- remove this and the other listener --> |
| <currentTarget var="target" obj="evt"/> |
| <for-each collection="listeners" member="listener"> |
| <removeEventListener obj="target" type='"foo"' listener="listener" useCapture="false"/> |
| </for-each> |
| </handleEvent> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <append collection="listeners" item="listener1"/> |
| <append collection="listeners" item="listener2"/> |
| <addEventListener obj="doc" type='"foo"' listener="listener1" useCapture="false"/> |
| <addEventListener obj="doc" type='"foo"' listener="listener2" useCapture="false"/> |
| <createEvent var="evt" obj="doc" eventType='"Events"'/> |
| <initEvent obj="evt" eventTypeArg='"foo"' canBubbleArg="true" cancelableArg="false"/> |
| <dispatchEvent var="preventDefault" obj="doc" evt="evt"/> |
| <assertSize id="eventCount" collection="events" size="1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/files/.cvsignore |
|---|
| --- test/testcases/tests/level2/events/files/CVS/Entries (nonexistent) |
| +++ test/testcases/tests/level2/events/files/CVS/Entries (revision 4364) |
| @@ -0,0 +1,10 @@ |
| +/.cvsignore/1.2/Fri Apr 3 02:47:56 2009// |
| +/hc_staff.html/1.5/Fri Apr 3 02:47:56 2009// |
| +/hc_staff.svg/1.2/Fri Apr 3 02:47:56 2009/-kb/ |
| +/hc_staff.xhtml/1.5/Fri Apr 3 02:47:56 2009/-kb/ |
| +/hc_staff.xml/1.6/Fri Apr 3 02:47:56 2009// |
| +/staff.dtd/1.1/Fri Apr 3 02:47:56 2009// |
| +/svgtest.js/1.1/Fri Apr 3 02:47:56 2009/-kb/ |
| +/svgunit.js/1.1/Fri Apr 3 02:47:56 2009/-kb/ |
| +/xhtml1-strict.dtd/1.5/Fri Apr 3 02:47:56 2009/-kb/ |
| +D |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level2/events/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/files/CVS/Template |
|---|
| --- test/testcases/tests/level2/events/files/hc_staff.html (nonexistent) |
| +++ test/testcases/tests/level2/events/files/hc_staff.html (revision 4364) |
| @@ -0,0 +1,48 @@ |
| +<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" |
| + "http://www.w3.org/TR/html4/strict.dtd" > |
| +<!-- This is comment number 1.--> |
| +<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>hc_staff</title><script type="text/javascript" src="svgunit.js"></script><script charset="UTF-8" type="text/javascript" src="svgtest.js"></script><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| + <p> |
| + <em>EMP0001</em> |
| + <strong>Margaret Martin</strong> |
| + <code>Accountant</code> |
| + <sup>56,000</sup> |
| + <var>Female</var> |
| + <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| + </p> |
| + <p> |
| + <em>EMP0002</em> |
| + <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| +This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| + <code>Secretary</code> |
| + <sup>35,000</sup> |
| + <var>Female</var> |
| + <acronym title="Yes" class="Yes">β Dallas, γ |
| + 98554</acronym> |
| + </p> |
| + <p> |
| + <em>EMP0003</em> |
| + <strong>Roger |
| + Jones</strong> |
| + <code>Department Manager</code> |
| + <sup>100,000</sup> |
| + <var>δ</var> |
| + <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| + </p> |
| + <p> |
| + <em>EMP0004</em> |
| + <strong>Jeny Oconnor</strong> |
| + <code>Personnel Director</code> |
| + <sup>95,000</sup> |
| + <var>Female</var> |
| + <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| + </p> |
| + <p> |
| + <em>EMP0005</em> |
| + <strong>Robert Myers</strong> |
| + <code>Computer Specialist</code> |
| + <sup>90,000</sup> |
| + <var>male</var> |
| + <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| + </p> |
| +</body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/files/hc_staff.svg |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST acronym dir CDATA "ltr"> |
| <!ATTLIST head xmlns CDATA #IMPLIED> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| <!ELEMENT svg (rect, script, head, body)> |
| <!ATTLIST svg xmlns CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #IMPLIED |
| y CDATA #IMPLIED |
| width CDATA #IMPLIED |
| height CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <!-- This is comment number 1.--> |
| <svg xmlns='http://www.w3.org/2000/svg'><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script><head xmlns='http://www.w3.org/1999/xhtml'><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title></head><body xmlns='http://www.w3.org/1999/xhtml'> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p> |
| <em>EMP0002</em> |
| <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>δ</var> |
| <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/files/hc_staff.xhtml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST acronym dir CDATA "ltr"> |
| ]> |
| <!-- This is comment number 1.--> |
| <html xmlns='http://www.w3.org/1999/xhtml'><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title><script type="text/javascript" src="svgunit.js"/><script charset="UTF-8" type="text/javascript" src="svgtest.js"/><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p> |
| <em>EMP0002</em> |
| <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>δ</var> |
| <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/files/hc_staff.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST acronym dir CDATA "ltr"> |
| ]> |
| <!-- This is comment number 1.--> |
| <html xmlns='http://www.w3.org/1999/xhtml'><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title><script type="text/javascript" src="svgunit.js"/><script charset="UTF-8" type="text/javascript" src="svgtest.js"/><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p> |
| <em>EMP0002</em> |
| <strong>Martha RaynoldsThis is a CDATASection with EntityReference number 2 &ent2; |
| This is an adjacent CDATASection with a reference to a tab &tab;</strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>δ</var> |
| <acronym title="Yes" class="No">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/files/staff.dtd |
|---|
| 0,0 → 1,17 |
| <!ELEMENT employeeId (#PCDATA)> |
| <!ELEMENT name (#PCDATA)> |
| <!ELEMENT position (#PCDATA)> |
| <!ELEMENT salary (#PCDATA)> |
| <!ELEMENT address (#PCDATA)> |
| <!ELEMENT entElement ( #PCDATA ) > |
| <!ELEMENT gender ( #PCDATA | entElement )* > |
| <!ELEMENT employee (employeeId, name, position, salary, gender, address) > |
| <!ELEMENT staff (employee)+> |
| <!ATTLIST entElement |
| attr1 CDATA "Attr"> |
| <!ATTLIST address |
| domestic CDATA #IMPLIED |
| street CDATA "Yes"> |
| <!ATTLIST entElement |
| domestic CDATA "MALE" > |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/files/xhtml1-strict.dtd |
|---|
| 0,0 → 1,65 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This is a radically simplified DTD for use in the DOM Test Suites |
| due to a XML non-conformance of one implementation in processing |
| parameter entities. When that non-conformance is resolved, |
| this DTD can be replaced by the normal DTD for XHTML. |
| --> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (meta,title,script*)> |
| <!ELEMENT meta EMPTY> |
| <!ATTLIST meta |
| http-equiv CDATA #IMPLIED |
| content CDATA #IMPLIED> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT body (p*)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|em|strong|code|sup|var|acronym|abbr)*> |
| <!ATTLIST p |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT em (#PCDATA)> |
| <!ELEMENT span (#PCDATA)> |
| <!ELEMENT strong (#PCDATA)> |
| <!ELEMENT code (#PCDATA)> |
| <!ELEMENT sup (#PCDATA)> |
| <!ELEMENT var (#PCDATA|span)*> |
| <!ELEMENT acronym (#PCDATA)> |
| <!ATTLIST acronym |
| title CDATA #IMPLIED |
| class CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT abbr (#PCDATA)> |
| <!ATTLIST abbr |
| title CDATA #IMPLIED |
| class CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| type CDATA #IMPLIED |
| src CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/initEvent01.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="initEvent01"> |
| <metadata> |
| <title>initEvent01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The Event.initEvent method is called for event returned by DocumentEvent.createEvent("events") |
| and the state is checked to see if it reflects the parameters. |
| </description> |
| <date qualifier="created">2002-04-22</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-Event-initEvent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="event" type="Event"/> |
| <var name="expectedEventType" type="DOMString" value='"rotate"'/> |
| <var name="actualEventType" type="DOMString"/> |
| <var name="expectedCanBubble" type="boolean" value='true'/> |
| <var name="actualCanBubble" type="boolean"/> |
| <var name="expectedCancelable" type="boolean" value='false'/> |
| <var name="actualCancelable" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"Events"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| <initEvent obj="event" eventTypeArg="expectedEventType" |
| canBubbleArg="expectedCanBubble" cancelableArg="expectedCancelable"/> |
| <type var="actualEventType" obj="event" interface="Event"/> |
| <assertEquals actual="actualEventType" expected="expectedEventType" id="type" ignoreCase="false"/> |
| <cancelable var="actualCancelable" obj="event"/> |
| <assertEquals actual="actualCancelable" expected="expectedCancelable" id="cancelable" ignoreCase="false"/> |
| <bubbles var="actualCanBubble" obj="event"/> |
| <assertEquals actual="actualCanBubble" expected="expectedCanBubble" id="canBubble" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/initEvent02.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="initEvent02"> |
| <metadata> |
| <title>initEvent02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The Event.initEvent method is called for event returned by DocumentEvent.createEvent("events") |
| and the state is checked to see if it reflects the parameters. |
| </description> |
| <date qualifier="created">2002-04-22</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-Event-initEvent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="event" type="Event"/> |
| <var name="expectedEventType" type="DOMString" value='"rotate"'/> |
| <var name="actualEventType" type="DOMString"/> |
| <var name="expectedCanBubble" type="boolean" value='false'/> |
| <var name="actualCanBubble" type="boolean"/> |
| <var name="expectedCancelable" type="boolean" value='true'/> |
| <var name="actualCancelable" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"Events"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| <initEvent obj="event" eventTypeArg="expectedEventType" |
| canBubbleArg="expectedCanBubble" cancelableArg="expectedCancelable"/> |
| <type var="actualEventType" obj="event" interface="Event"/> |
| <assertEquals actual="actualEventType" expected="expectedEventType" id="type" ignoreCase="false"/> |
| <cancelable var="actualCancelable" obj="event"/> |
| <assertEquals actual="actualCancelable" expected="expectedCancelable" id="cancelable" ignoreCase="false"/> |
| <bubbles var="actualCanBubble" obj="event"/> |
| <assertEquals actual="actualCanBubble" expected="expectedCanBubble" id="canBubble" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/initEvent03.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="initEvent03"> |
| <metadata> |
| <title>initEvent03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The Event.initEvent method is called for event returned by DocumentEvent.createEvent("events") |
| and the state is checked to see if it reflects the parameters. initEvent may be |
| called multiple times and the last time is definitive. |
| </description> |
| <date qualifier="created">2002-04-22</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-Event-initEvent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="event" type="Event"/> |
| <var name="expectedEventType" type="DOMString" value='"rotate"'/> |
| <var name="actualEventType" type="DOMString"/> |
| <var name="actualCanBubble" type="boolean"/> |
| <var name="actualCancelable" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"Events"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| <initEvent obj="event" eventTypeArg='"rotate"' |
| canBubbleArg="true" cancelableArg="true"/> |
| <type var="actualEventType" obj="event" interface="Event"/> |
| <assertEquals actual="actualEventType" expected='"rotate"' id="type" ignoreCase="false"/> |
| <cancelable var="actualCancelable" obj="event"/> |
| <assertEquals actual="actualCancelable" expected="true" id="cancelable" ignoreCase="false"/> |
| <bubbles var="actualCanBubble" obj="event"/> |
| <assertEquals actual="actualCanBubble" expected="true" id="canBubble" ignoreCase="false"/> |
| <initEvent obj="event" eventTypeArg='"shear"' |
| canBubbleArg="false" cancelableArg="false"/> |
| <type var="actualEventType" obj="event" interface="Event"/> |
| <assertEquals actual="actualEventType" expected='"shear"' id="type2" ignoreCase="false"/> |
| <cancelable var="actualCancelable" obj="event"/> |
| <assertEquals actual="actualCancelable" expected="false" id="cancelable2" ignoreCase="false"/> |
| <bubbles var="actualCanBubble" obj="event"/> |
| <assertEquals actual="actualCanBubble" expected="false" id="canBubble2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/initEvent04.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="initEvent04"> |
| <metadata> |
| <title>initEvent04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The Event.initEvent method is called for event returned by |
| DocumentEvent.createEvent("MutationEvents") |
| and the state is checked to see if it reflects the parameters. |
| </description> |
| <date qualifier="created">2002-04-22</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-Event-initEvent"/> |
| </metadata> |
| <hasFeature feature='"MutationEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="event" type="Event"/> |
| <var name="expectedEventType" type="DOMString" value='"rotate"'/> |
| <var name="actualEventType" type="DOMString"/> |
| <var name="expectedCanBubble" type="boolean" value='true'/> |
| <var name="actualCanBubble" type="boolean"/> |
| <var name="expectedCancelable" type="boolean" value='false'/> |
| <var name="actualCancelable" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"MutationEvents"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| <initEvent obj="event" eventTypeArg="expectedEventType" |
| canBubbleArg="expectedCanBubble" cancelableArg="expectedCancelable"/> |
| <type var="actualEventType" obj="event" interface="Event"/> |
| <assertEquals actual="actualEventType" expected="expectedEventType" id="type" ignoreCase="false"/> |
| <cancelable var="actualCancelable" obj="event"/> |
| <assertEquals actual="actualCancelable" expected="expectedCancelable" id="cancelable" ignoreCase="false"/> |
| <bubbles var="actualCanBubble" obj="event"/> |
| <assertEquals actual="actualCanBubble" expected="expectedCanBubble" id="canBubble" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/initEvent05.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="initEvent05"> |
| <metadata> |
| <title>initEvent05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The Event.initEvent method is called for event returned by |
| DocumentEvent.createEvent("MutationEvents") |
| and the state is checked to see if it reflects the parameters. |
| </description> |
| <date qualifier="created">2002-04-22</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-Event-initEvent"/> |
| </metadata> |
| <hasFeature feature='"MutationEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="event" type="Event"/> |
| <var name="expectedEventType" type="DOMString" value='"rotate"'/> |
| <var name="actualEventType" type="DOMString"/> |
| <var name="expectedCanBubble" type="boolean" value='false'/> |
| <var name="actualCanBubble" type="boolean"/> |
| <var name="expectedCancelable" type="boolean" value='true'/> |
| <var name="actualCancelable" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"MutationEvents"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| <initEvent obj="event" eventTypeArg="expectedEventType" |
| canBubbleArg="expectedCanBubble" cancelableArg="expectedCancelable"/> |
| <type var="actualEventType" obj="event" interface="Event"/> |
| <assertEquals actual="actualEventType" expected="expectedEventType" id="type" ignoreCase="false"/> |
| <cancelable var="actualCancelable" obj="event"/> |
| <assertEquals actual="actualCancelable" expected="expectedCancelable" id="cancelable" ignoreCase="false"/> |
| <bubbles var="actualCanBubble" obj="event"/> |
| <assertEquals actual="actualCanBubble" expected="expectedCanBubble" id="canBubble" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/initEvent06.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="initEvent06"> |
| <metadata> |
| <title>initEvent06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The Event.initEvent method is called for event returned by |
| DocumentEvent.createEvent("MutationEvents") |
| and the state is checked to see if it reflects the parameters. initEvent may be |
| called multiple times and the last time is definitive. |
| </description> |
| <date qualifier="created">2002-04-22</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Events/events#Events-Event-initEvent"/> |
| </metadata> |
| <hasFeature feature='"MutationEvents"' version='"2.0"'/> |
| <var name="doc" type="Document"/> |
| <var name="event" type="Event"/> |
| <var name="expectedEventType" type="DOMString" value='"rotate"'/> |
| <var name="actualEventType" type="DOMString"/> |
| <var name="actualCanBubble" type="boolean"/> |
| <var name="actualCancelable" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEvent var="event" obj="doc" eventType='"MutationEvents"'/> |
| <assertNotNull actual="event" id="notnull"/> |
| <initEvent obj="event" eventTypeArg='"rotate"' |
| canBubbleArg="true" cancelableArg="true"/> |
| <type var="actualEventType" obj="event" interface="Event"/> |
| <assertEquals actual="actualEventType" expected='"rotate"' id="type" ignoreCase="false"/> |
| <cancelable var="actualCancelable" obj="event"/> |
| <assertEquals actual="actualCancelable" expected="true" id="cancelable" ignoreCase="false"/> |
| <bubbles var="actualCanBubble" obj="event"/> |
| <assertEquals actual="actualCanBubble" expected="true" id="canBubble" ignoreCase="false"/> |
| <initEvent obj="event" eventTypeArg='"shear"' |
| canBubbleArg="false" cancelableArg="false"/> |
| <type var="actualEventType" obj="event" interface="Event"/> |
| <assertEquals actual="actualEventType" expected='"shear"' id="type2" ignoreCase="false"/> |
| <cancelable var="actualCancelable" obj="event"/> |
| <assertEquals actual="actualCancelable" expected="false" id="cancelable2" ignoreCase="false"/> |
| <bubbles var="actualCanBubble" obj="event"/> |
| <assertEquals actual="actualCanBubble" expected="false" id="canBubble2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/events/metadata.xml |
|---|
| 0,0 → 1,20 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE metadata SYSTEM "dom2.dtd"> |
| <!-- This file contains additional metadata about DOM L2 Events tests. |
| Allowing additional documentation without modifying the tests themselves. --> |
| <metadata xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2"> |
| </metadata> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/.cvsignore |
|---|
| 0,0 → 1,2 |
| dom2.dtd |
| dom2.xsd |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/CVS/Entries |
|---|
| 0,0 → 1,65 |
| D/files//// |
| /.cvsignore/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLAppletElement07.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /HTMLAppletElement09.xml/1.5/Fri Apr 3 02:47:56 2009// |
| /HTMLBaseFontElement03.xml/1.6/Fri Apr 3 02:47:56 2009// |
| /HTMLBodyElement07.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLBodyElement08.xml/1.2/Fri Apr 3 02:47:55 2009// |
| /HTMLBodyElement09.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLBodyElement10.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLBodyElement11.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLBodyElement12.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLDocument22.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLDocument23.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLDocument24.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLDocument25.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLDocument26.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLDocument27.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLFrameElement09.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLIFrameElement11.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /HTMLImageElement05.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /HTMLImageElement06.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /HTMLImageElement11.xml/1.3/Fri Apr 3 02:47:56 2009// |
| /HTMLImageElement12.xml/1.3/Fri Apr 3 02:47:55 2009// |
| /HTMLInputElement13.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /HTMLObjectElement11.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /HTMLObjectElement16.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /HTMLObjectElement20.xml/1.1/Fri Apr 3 02:47:55 2009// |
| /HTMLOptionsCollection01.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLOptionsCollection02.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLOptionsCollection03.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLOptionsCollection04.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLOptionsCollection05.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLOptionsCollection06.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLOptionsCollection07.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLSelectElement20.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableElement34.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableElement35.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableElement36.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableElement37.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableElement38.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableElement39.xml/1.1/Fri Apr 3 02:47:55 2009// |
| /HTMLTableElement40.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableRowElement15.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableRowElement16.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLTableRowElement17.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLTableRowElement18.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLTableRowElement19.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /HTMLTableRowElement20.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableRowElement21.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableSectionElement25.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableSectionElement26.xml/1.1/Fri Apr 3 02:47:55 2009// |
| /HTMLTableSectionElement27.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableSectionElement28.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableSectionElement29.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableSectionElement30.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /HTMLTableSectionElement31.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /alltests.xml/1.19/Fri Apr 3 02:47:56 2009// |
| /hasFeature02.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /hasFeature03.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /hasFeature04.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /hasFeature05.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /hasFeature06.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /metadata.xml/1.1/Fri Apr 3 02:47:55 2009// |
| /object08.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /object13.xml/1.2/Fri Apr 3 02:47:56 2009// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level2/html |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/CVS/Template |
|---|
| --- test/testcases/tests/level2/html/HTMLAppletElement07.xml (nonexistent) |
| +++ test/testcases/tests/level2/html/HTMLAppletElement07.xml (revision 4364) |
| @@ -0,0 +1,42 @@ |
| +<?xml version="1.0" encoding="UTF-8"?> |
| + |
| +<!-- |
| + |
| +Copyright (c) 2001 World Wide Web Consortium, |
| +(Massachusetts Institute of Technology, Institut National de |
| +Recherche en Informatique et en Automatique, Keio University). All |
| +Rights Reserved. This program is distributed under the W3C's Software |
| +Intellectual Property License. This program is distributed in the |
| +hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| +PURPOSE. |
| + |
| +See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| + |
| +--> |
| +<!DOCTYPE test SYSTEM "dom2.dtd"> |
| +<test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLAppletElement07"> |
| +<metadata> |
| +<title>HTMLAppletElement07</title> |
| +<creator>NIST</creator> |
| +<description> |
| + The hspace attribute specifies the horizontal space to the left |
| + and right of this image, applet, or object. |
| + |
| + Retrieve the hspace attribute and examine it's value. |
| +</description> |
| +<contributor>Mary Brady</contributor> |
| +<date qualifier="created">2001-12-03</date> |
| +<subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-1567197"/> |
| +</metadata> |
| +<var name="nodeList" type="NodeList"/> |
| +<var name="testNode" type="Node"/> |
| +<var name="vhspace" type="int"/> |
| +<var name="doc" type="Node"/> |
| +<load var="doc" href="applet" willBeModified="false"/> |
| +<getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""applet""/> |
| +<assertSize collection="nodeList" size="1" id="Asize"/> |
| +<item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| +<hspace interface="HTMLAppletElement" obj="testNode" var="vhspace"/> |
| +<assertEquals actual="vhspace" expected="0" id="hspaceLink" ignoreCase="false"/> |
| +</test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLAppletElement09.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLAppletElement09"> |
| <metadata> |
| <title>HTMLAppletElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The vspace attribute specifies the vertical space above and below |
| this image, applet or object. |
| Retrieve the vspace attribute and examine it's value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-12-03</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-22637173"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvspace" type="int"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="applet" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""applet""/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vspace interface="HTMLAppletElement" obj="testNode" var="vvspace"/> |
| <assertEquals actual="vvspace" expected="0" id="vspaceLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLBaseFontElement03.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLBaseFontElement03"> |
| <metadata> |
| <title>HTMLBaseFontElement03</title> |
| <creator>NIST</creator> |
| <description> |
| The size attribute specifies the base font's size. |
| Retrieve the size attribute and examine it's value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-12-03</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-38930424"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsize" type="int"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="basefont" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""basefont""/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <size interface="HTMLBaseFontElement" obj="testNode" var="vsize"/> |
| <assertEquals actual="vsize" expected="4" id="sizeLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLBodyElement07.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLBodyElement07"> |
| <metadata> |
| <title>HTMLBodyElement07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("hTmL", null) returns true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-62018039"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="body" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <body var="body" obj="doc"/> |
| <isSupported var="state" obj="body" feature='"hTmL"' version="version"/> |
| <assertTrue actual="state" id="isSupportedHTML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLBodyElement08.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLBodyElement08"> |
| <metadata> |
| <title>HTMLBodyElement08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("hTmL", "2.0") returns true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-62018039"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="body" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="version" type="DOMString" value='"2.0"'/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <body var="body" obj="doc"/> |
| <isSupported var="state" obj="body" feature='"hTmL"' version="version"/> |
| <assertTrue actual="state" id="isSupportedHTML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLBodyElement09.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLBodyElement09"> |
| <metadata> |
| <title>HTMLBodyElement09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("xhTmL", null) returns true if hasFeature("XML", null) is true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-62018039"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="body" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="hasXML" type="boolean"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <body var="body" obj="doc"/> |
| <isSupported var="hasXML" obj="body" feature='"XML"' version="version"/> |
| <isSupported var="state" obj="body" feature='"xhTmL"' version="version"/> |
| <assertEquals actual="state" expected="hasXML" id="isSupportedXHTML" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLBodyElement10.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLBodyElement10"> |
| <metadata> |
| <title>HTMLBodyElement10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("xhTmL", "2.0") returns true if hasFeature("XML", "2.0") is true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-62018039"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="body" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="hasXML" type="boolean"/> |
| <var name="version" type="DOMString" value='"2.0"'/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <body var="body" obj="doc"/> |
| <isSupported var="hasXML" obj="body" feature='"XML"' version="version"/> |
| <isSupported var="state" obj="body" feature='"xhTmL"' version="version"/> |
| <assertEquals actual="state" expected="hasXML" id="isSupportedXHTML" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLBodyElement11.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLBodyElement11"> |
| <metadata> |
| <title>HTMLBodyElement11</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("cOrE", null) returns true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-62018039"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="body" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <body var="body" obj="doc"/> |
| <isSupported var="state" obj="body" feature='"cOrE"' version="version"/> |
| <assertTrue actual="state" id="isSupportedCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLBodyElement12.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLBodyElement12"> |
| <metadata> |
| <title>HTMLBodyElement12</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("cOrE", "2.0") returns true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-62018039"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="body" type="Element"/> |
| <var name="state" type="boolean"/> |
| <var name="version" type="DOMString" value='"2.0"'/> |
| <load var="doc" href="document" willBeModified="false"/> |
| <body var="body" obj="doc"/> |
| <isSupported var="state" obj="body" feature='"cOrE"' version="version"/> |
| <assertTrue actual="state" id="isSupportedCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLDocument22.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLDocument22"> |
| <metadata> |
| <title>HTMLDocument22</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("hTmL", null) returns true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-26809268"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <isSupported var="state" obj="doc" feature='"hTmL"' version="version"/> |
| <assertTrue actual="state" id="isSupportedHTML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLDocument23.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLDocument23"> |
| <metadata> |
| <title>HTMLDocument23</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("hTmL", "2.0") returns true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-26809268"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <var name="version" type="DOMString" value='"2.0"'/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <isSupported var="state" obj="doc" feature='"hTmL"' version="version"/> |
| <assertTrue actual="state" id="isSupportedHTML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLDocument24.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLDocument24"> |
| <metadata> |
| <title>HTMLDocument24</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("xhTmL", null) returns true if hasFeature("XML", null) is true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-26809268"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <var name="hasXML" type="boolean"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <isSupported var="hasXML" obj="doc" feature='"XML"' version="version"/> |
| <isSupported var="state" obj="doc" feature='"xhTmL"' version="version"/> |
| <assertEquals actual="state" expected="hasXML" id="isSupportedXHTML" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLDocument25.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLDocument25"> |
| <metadata> |
| <title>HTMLDocument25</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("xhTmL", "2.0") returns true if hasFeature("XML", "2.0") is true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-26809268"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <var name="hasXML" type="boolean"/> |
| <var name="version" type="DOMString" value='"2.0"'/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <isSupported var="hasXML" obj="doc" feature='"XML"' version="version"/> |
| <isSupported var="state" obj="doc" feature='"xhTmL"' version="version"/> |
| <assertEquals actual="state" expected="hasXML" id="isSupportedXHTML" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLDocument26.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLDocument26"> |
| <metadata> |
| <title>HTMLDocument26</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("cOrE", null) returns true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-26809268"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <isSupported var="state" obj="doc" feature='"cOrE"' version="version"/> |
| <assertTrue actual="state" id="isSupportedCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLDocument27.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xml" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLDocument27"> |
| <metadata> |
| <title>HTMLDocument27</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that Node.isSupported("cOrE", "2.0") returns true. |
| </description> |
| <date qualifier="created">2002-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#Level-2-Core-Node-supports"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-26809268"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <var name="version" type="DOMString" value='"2.0"'/> |
| <load var="doc" href="document" willBeModified="true"/> |
| <isSupported var="state" obj="doc" feature='"cOrE"' version="version"/> |
| <assertTrue actual="state" id="isSupportedCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLFrameElement09.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLFrameElement09"> |
| <metadata> |
| <title>HTMLFrameElement09</title> |
| <creator>NIST</creator> |
| <description> |
| The contentDocument attribute specifies the document this frame contains, |
| if there is any and it is available, or null otherwise. |
| Retrieve the contentDocument attribute of the first FRAME element |
| and examine its TITLE value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-03</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-78799536"/> |
| </metadata> |
| <var name="testNode" type="Element"/> |
| <var name="cd" type="Document" /> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="frame2" willBeModified="false"/> |
| <getElementById interface="Document" obj="doc" var="testNode" elementId='"Frame1"'/> |
| <contentDocument interface="HTMLFrameElement" obj="testNode" var="cd"/> |
| <title interface="HTMLDocument" obj="cd" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"NIST DOM HTML Test - FRAMESET"' id="titleLink" ignoreCase="false" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLIFrameElement11.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLIFrameElement11"> |
| <metadata> |
| <title>HTMLIFrameElement11</title> |
| <creator>NIST</creator> |
| <description> |
| Retrieve the contentDocument attribute of the second IFRAME element |
| and examine its title. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-03</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-67133006"/> |
| </metadata> |
| <var name="testNode" type="Element"/> |
| <var name="cd" type="Document" /> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="iframe2" willBeModified="false"/> |
| <getElementById interface="Document" obj="doc" var="testNode" elementId='"Iframe2"'/> |
| <contentDocument interface="HTMLIFrameElement" obj="testNode" var="cd"/> |
| <title interface="HTMLDocument" obj="cd" var="vtitle"/> |
| <assertEquals actual="vtitle" expected='"NIST DOM HTML Test - FRAME"' id="titleLink" ignoreCase="false" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLImageElement05.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLImageElement05"> |
| <metadata> |
| <title>HTMLImageElement05</title> |
| <creator>NIST</creator> |
| <description> |
| The height attribute overrides the natural "height" of the image. |
| Retrieve the height attribute and examine it's value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-12-26</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-91561496"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vheight" type="int"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""img""/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <height interface="HTMLImageElement" obj="testNode" var="vheight"/> |
| <assertEquals actual="vheight" expected="47" id="heightLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLImageElement06.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLImageElement06"> |
| <metadata> |
| <title>HTMLImageElement06</title> |
| <creator>NIST</creator> |
| <description> |
| The hspace attribute specifies the horizontal space to the left and |
| right of this image. |
| Retrieve the hspace attribute and examine it's value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-12-26</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-53675471"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhspace" type="int"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""img""/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <hspace interface="HTMLImageElement" obj="testNode" var="vhspace"/> |
| <assertEquals actual="vhspace" expected="4" id="hspaceLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLImageElement11.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLImageElement11"> |
| <metadata> |
| <title>HTMLImageElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The vspace attribute specifies the vertical space above and below this |
| image. |
| Retrieve the vspace attribute and examine it's value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-12-26</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-85374897"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvspace" type="int"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""img""/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vspace interface="HTMLImageElement" obj="testNode" var="vvspace"/> |
| <assertEquals actual="vvspace" expected="10" id="vspaceLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLImageElement12.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLImageElement12"> |
| <metadata> |
| <title>HTMLImageElement12</title> |
| <creator>NIST</creator> |
| <description> |
| The width attribute overrides the natural "width" of the image. |
| Retrieve the width attribute and examine it's value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-12-07</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-13839076"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vwidth" type="int"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="img" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""img""/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <width interface="HTMLImageElement" obj="testNode" var="vwidth"/> |
| <assertEquals actual="vwidth" expected="115" id="widthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLInputElement13.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLInputElement13"> |
| <metadata> |
| <title>HTMLInputElement13</title> |
| <creator>NIST</creator> |
| <description> |
| The size attribute contains the size information. Its precise meaning |
| is specific to each type of field. |
| Retrieve the size attribute of the 1st INPUT element and examine |
| its value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2001-12-26</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-79659438"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vsize" type="int"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="input" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"input"'/> |
| <assertSize collection="nodeList" size="9" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <size interface="HTMLInputElement" obj="testNode" var="vsize"/> |
| <assertEquals actual="vsize" expected="25" id="size" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLObjectElement11.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLObjectElement11"> |
| <metadata> |
| <title>HTMLObjectElement11</title> |
| <creator>NIST</creator> |
| <description> |
| The hspace attribute specifies the horizontal space to the left and right |
| of this image, applet or object. |
| Retrieve the hspace attribute of the first OBJECT element and examine |
| it's value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-01-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-17085376"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhspace" type="int"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""object""/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <hspace interface="HTMLObjectElement" obj="testNode" var="vhspace"/> |
| <assertEquals actual="vhspace" expected="0" id="hspaceLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLObjectElement16.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLObjectElement16"> |
| <metadata> |
| <title>HTMLObjectElement16</title> |
| <creator>NIST</creator> |
| <description> |
| The vspace attribute specifies the vertical space above or below this |
| image, applet or object. |
| Retrieve the vspace attribute of the first OBJECT element and examine |
| it's value. |
| </description> |
| <contributor>Mary Brady</contributor> |
| <date qualifier="created">2002-01-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-8682483"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvspace" type="int"/> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""object""/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vspace interface="HTMLObjectElement" obj="testNode" var="vvspace"/> |
| <assertEquals actual="vvspace" expected="0" id="vspaceLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLObjectElement20.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLObjectElement20"> |
| <metadata> |
| <title>HTMLObjectElement20</title> |
| <creator>NIST</creator> |
| <description> |
| The contentDocument attribute specifies the document this object contains, |
| if there is any and it is available, or null otherwise. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-07-03</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-38538621"/> |
| </metadata> |
| <var name="testNode" type="Element"/> |
| <var name="cd" type="Document" /> |
| <var name="vtitle" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <var name="nodeList" type="NodeList"/> |
| <load var="doc" href="object2" willBeModified="false"/> |
| <getElementsByTagName var="nodeList" obj="doc" interface="Document" tagname='"object"'/> |
| <item var="testNode" obj="nodeList" index="1" interface="NodeList"/> |
| <contentDocument interface="HTMLObjectElement" obj="testNode" var="cd"/> |
| <assertNull actual="cd" id="noContentDocument"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLOptionsCollection01.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLOptionsCollection01"> |
| <metadata> |
| <title>HTMLOptionsCollection01</title> |
| <creator>NIST</creator> |
| <description> |
| An HTMLOptionsCollection is a list of nodes representing HTML option |
| element. |
| The length attribute specifies the length or size of the list. |
| Retrieve the first SELECT element and create a HTMLOptionsCollection |
| of the OPTION elements. Check the size of the length of OPTION elements. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-08-01</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#HTMLOptionsCollection-length"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="optionsList" type="HTMLOptionsCollection"/> |
| <var name="vlength" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="optionscollection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <options interface="HTMLSelectElement" obj="testNode" var="optionsList"/> |
| <length interface="HTMLOptionsCollection" obj="optionsList" var="vlength"/> |
| <assertEquals actual="vlength" expected="5" id="lengthLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLOptionsCollection02.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLOptionsCollection02"> |
| <metadata> |
| <title>HTMLOptionsCollection02</title> |
| <creator>NIST</creator> |
| <description> |
| An HTMLOptionsCollection is a list of nodes representing HTML option |
| element. |
| An individual node may be accessed by either ordinal index, the node's |
| name or id attributes. (Test ordinal index=3). |
| The item() method retrieves a node specified by ordinal index. |
| Nodes are numbered in tree order. The index origin is 0. |
| Retrieve the first SELECT element. Create a HTMLOptionsCollection. |
| Retrieve the fourth item in the list and examine its firstChild's |
| nodeValue. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-08-01</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#HTMLOptionsCollection-item"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="optionsNode" type="Node"/> |
| <var name="optionsValueNode" type="Node"/> |
| <var name="optionsList" type="HTMLOptionsCollection"/> |
| <var name="vvalue" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="optionscollection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <options interface="HTMLSelectElement" obj="testNode" var="optionsList"/> |
| <item interface="HTMLOptionsCollection" obj="optionsList" var="optionsNode" index="3"/> |
| <firstChild interface="Node" obj="optionsNode" var="optionsValueNode"/> |
| <nodeValue obj="optionsValueNode" var="vvalue"/> |
| <assertEquals actual="vvalue" expected='"EMP10004"' id="valueIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLOptionsCollection03.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLOptionsCollection03"> |
| <metadata> |
| <title>HTMLOptionsCollection03</title> |
| <creator>NIST</creator> |
| <description> |
| An HTMLOptionsCollection is a list of nodes representing HTML option |
| element. |
| An individual node may be accessed by either ordinal index, the node's |
| name or id attributes. (Test node name). |
| The namedItem method retrieves a Node using a name. It first searches |
| for a node with a matching id attribute. If it doesn't find one, it |
| then searches for a Node with a matching name attribute, but only |
| those elements that are allowed a name attribute. |
| Retrieve the first FORM element. Create a HTMLCollection of the elements. |
| Search for an element that has select1 as the value for the name attribute. |
| Get the nodeName of that element. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-08-01</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#HTMLOptionsCollection-namedItem"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="optionsNode" type="Node"/> |
| <var name="formsnodeList" type="HTMLCollection"/> |
| <var name="vname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="optionscollection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <elements interface="HTMLFormElement" obj="testNode" var="formsnodeList"/> |
| <namedItem interface="HTMLOptionsCollection" obj="formsnodeList" var="optionsNode" name='"select1"'/> |
| <nodeName obj="optionsNode" var="vname"/> |
| <assertEquals actual="vname" expected='"select"' id="nameIndexLink" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLOptionsCollection04.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLOptionsCollection04"> |
| <metadata> |
| <title>HTMLOptionsCollection04</title> |
| <creator>NIST</creator> |
| <description> |
| An HTMLOptionsCollection is a list of nodes representing HTML option |
| element. |
| An individual node may be accessed by either ordinal index, the node's |
| name or id attributes. (Test node name). |
| The namedItem method retrieves a Node using a name. It first searches |
| for a node with a matching id attribute. If it doesn't find one, it |
| then searches for a Node with a matching name attribute, but only |
| those elements that are allowed a name attribute. |
| Retrieve the first FORM element. Create a HTMLCollection of the elements. |
| Search for an element that has selectId as the value for the id attribute. |
| Get the nodeName of that element. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-08-01</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#HTMLOptionsCollection-namedItem"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="optionsNode" type="Node"/> |
| <var name="formsnodeList" type="HTMLCollection"/> |
| <var name="vname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="optionscollection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <elements interface="HTMLFormElement" obj="testNode" var="formsnodeList"/> |
| <namedItem interface="HTMLOptionsCollection" obj="formsnodeList" var="optionsNode" name='"selectId"'/> |
| <nodeName obj="optionsNode" var="vname"/> |
| <assertEquals actual="vname" expected='"select"' id="nameIndexLink" ignoreCase="auto"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLOptionsCollection05.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLOptionsCollection05"> |
| <metadata> |
| <title>HTMLOptionsCollection05</title> |
| <creator>NIST</creator> |
| <description> |
| An HTMLOptionsCollection is a list of nodes representing HTML option |
| element. |
| An individual node may be accessed by either ordinal index, the node's |
| name or id attributes. (Test node name). |
| The namedItem method retrieves a Node using a name. It first searches |
| for a node with a matching id attribute. If it doesn't find one, it |
| then searches for a Node with a matching name attribute, but only |
| those elements that are allowed a name attribute. Upon failure(e.q., no |
| node with this name exists), returns null. |
| Retrieve the first FORM element. Create a HTMLCollection of the elements. |
| Search for an element that has select9 as the value for the name attribute. |
| Null should be returned since there is not any name or id attribute with |
| select9 as a value. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-08-01</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#HTMLOptionsCollection-namedItem"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="optionsNode" type="Node"/> |
| <var name="formsnodeList" type="HTMLCollection"/> |
| <var name="vname" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="optionscollection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"form"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <elements interface="HTMLFormElement" obj="testNode" var="formsnodeList"/> |
| <namedItem interface="HTMLOptionsCollection" obj="formsnodeList" var="optionsNode" name='"select9"'/> |
| <assertNull actual="optionsNode" id="nameIndexLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLOptionsCollection06.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLOptionsCollection06"> |
| <metadata> |
| <title>HTMLOptionsCollection06</title> |
| <creator>NIST</creator> |
| <description> |
| An HTMLOptionsCollection is a list of nodes representing HTML option |
| element. |
| An individual node may be accessed by either ordinal index, the node's |
| name or id attributes. (Test ordinal index). |
| The item() method retrieves a node specified by ordinal index. |
| A value of null is returned if the index is out of range. |
| Retrieve the first SELECT element. Create a HTMLOptionsCollection. |
| Retrieve the tenth item in the list - null should be returned since |
| there are not 10 items in the list. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-08-01</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#HTMLOptionsCollection-item"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="optionsNode" type="Node"/> |
| <var name="optionsValueNode" type="Node"/> |
| <var name="optionsList" type="HTMLOptionsCollection"/> |
| <var name="vvalue" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="optionscollection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <options interface="HTMLSelectElement" obj="testNode" var="optionsList"/> |
| <item interface="HTMLOptionsCollection" obj="optionsList" var="optionsNode" index="10"/> |
| <assertNull actual="optionsNode" id="optionsIndexLink"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLOptionsCollection07.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLOptionsCollection07"> |
| <metadata> |
| <title>HTMLOptionsCollection07</title> |
| <creator>NIST</creator> |
| <description> |
| An HTMLOptionsCollection is a list of nodes representing HTML option |
| element. |
| An individual node may be accessed by either ordinal index, the node's |
| name or id attributes. (Test ordinal index=0). |
| The item() method retrieves a node specified by ordinal index. Nodes |
| are numbered in tree order. The index origin is 0. |
| Retrieve the first SELECT element. Create a HTMLOptionsCollection. |
| Retrieve the first item in the list and examine its firstChild's |
| nodeValue. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-08-01</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#HTMLOptionsCollection-item"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="optionsNode" type="Node"/> |
| <var name="optionsValueNode" type="Node"/> |
| <var name="optionsList" type="HTMLOptionsCollection"/> |
| <var name="vvalue" type="DOMString"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="optionscollection" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <options interface="HTMLSelectElement" obj="testNode" var="optionsList"/> |
| <item interface="HTMLOptionsCollection" obj="optionsList" var="optionsNode" index="0"/> |
| <firstChild interface="Node" obj="optionsNode" var="optionsValueNode"/> |
| <nodeValue obj="optionsValueNode" var="vvalue"/> |
| <assertEquals actual="vvalue" expected='"EMP10001"' id="valueIndexLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLSelectElement20.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLSelectElement20"> |
| <metadata> |
| <title>HTMLSelectElement20</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempting to add an new option using HTMLSelectElement.add before a node that is not a child of the select |
| element should raise a NOT_FOUND_ERR. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-14493106"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <var name="optLength" type="int"/> |
| <var name="selected" type="int"/> |
| <var name="newOpt" type="Element"/> |
| <var name="newOptText" type="Text"/> |
| <var name="retNode" type="Node"/> |
| <var name="options" type="HTMLCollection"/> |
| <var name="otherSelect" type="Element"/> |
| <var name="selectedNode" type="Node"/> |
| <load var="doc" href="select" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"select"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <item interface="NodeList" obj="nodeList" var="otherSelect" index="1"/> |
| <createElement var="newOpt" obj="doc" tagName='"option"'/> |
| <createTextNode var="newOptText" obj="doc" data='"EMP31415"'/> |
| <appendChild var="retNode" obj="newOpt" newChild="newOptText"/> |
| <options var="options" obj="otherSelect"/> |
| <item var="selectedNode" obj="options" index="0" interface="HTMLCollection"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <add interface="HTMLSelectElement" obj="testNode" element="newOpt" before="selectedNode"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableElement34.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableElement34"> |
| <metadata> |
| <title>HTMLTableElement34</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is greater than the number of rows. |
| Retrieve the second TABLE element which has four rows. Try |
| to insert a new row using an index of five. This should throw |
| a INDEX_SIZE_ERR DOMException since there are only four rows. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-39872903"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-39872903')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <assertDOMException id="HTMLTableElement34"> |
| <INDEX_SIZE_ERR> |
| <insertRow interface="HTMLTableElement" obj="testNode" var="newRow" index="5"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableElement35.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableElement35"> |
| <metadata> |
| <title>HTMLTableElement35</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is negative. |
| Retrieve the second TABLE element which has four rows. Try |
| to insert a new row using an index of negative five. This should throw |
| a INDEX_SIZE_ERR DOMException since the index is negative. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-39872903"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-39872903')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <assertDOMException id="HTMLTableElement35"> |
| <INDEX_SIZE_ERR> |
| <insertRow interface="HTMLTableElement" obj="testNode" var="newRow" index="-5"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableElement36.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableElement36"> |
| <metadata> |
| <title>HTMLTableElement36</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is greater than the number of rows. |
| Retrieve the second TABLE element which has four rows. Try |
| to delete a new row using an index of five. This should throw |
| a INDEX_SIZE_ERR DOMException since there are only four rows. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-13114938"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-13114938')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <assertDOMException id="HTMLTableElement36"> |
| <INDEX_SIZE_ERR> |
| <deleteRow interface="HTMLTableElement" obj="testNode" index="5"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableElement37.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableElement37"> |
| <metadata> |
| <title>HTMLTableElement37</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is equal the number of rows. |
| Retrieve the second TABLE element which has four rows. Try |
| to delete a new row using an index of four. This should throw |
| a INDEX_SIZE_ERR DOMException since the index is equal to the |
| number of rows. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-13114938"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-13114938')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <assertDOMException id="HTMLTableElement37"> |
| <INDEX_SIZE_ERR> |
| <deleteRow interface="HTMLTableElement" obj="testNode" index="4"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableElement38.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableElement38"> |
| <metadata> |
| <title>HTMLTableElement38</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is negative. |
| Retrieve the second TABLE element which has four rows. Try |
| to delete a new row using an index of negative five. This should throw |
| a INDEX_SIZE_ERR DOMException since the index is negative. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-13114938"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-13114938')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"table"'/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <assertDOMException id="HTMLTableElement38"> |
| <INDEX_SIZE_ERR> |
| <deleteRow interface="HTMLTableElement" obj="testNode" index="-5"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableElement39.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableElement39"> |
| <metadata> |
| <title>HTMLTableElement39</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. |
| If index is -1 or equal to the number of rows, the new row |
| is appended. |
| Retrieve the second TABLE element and invoke the insertRow() method |
| with an index of negative one. |
| The number of rows in the TBODY section before insertion with an index |
| of negative one is two. After the new row is inserted the number |
| of rows in the TBODY section is three. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-11-07</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-39872903"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="tbodiesnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="bodyNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vsection1" type="HTMLTableSectionElement"/> |
| <var name="vsection2" type="HTMLTableSectionElement"/> |
| <var name="vrows" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""table""/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <tBodies interface="HTMLTableElement" obj="testNode" var="tbodiesnodeList"/> |
| <item interface="HTMLCollection" obj="tbodiesnodeList" var="bodyNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="bodyNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink1" ignoreCase="false"/> |
| <insertRow interface="HTMLTableElement" obj="testNode" var="newRow" index="-1"/> |
| <tBodies interface="HTMLTableElement" obj="testNode" var="tbodiesnodeList"/> |
| <item interface="HTMLCollection" obj="tbodiesnodeList" var="bodyNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="bodyNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="3" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableElement40.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableElement40"> |
| <metadata> |
| <title>HTMLTableElement40</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method deletes a table row. If the index is -1 |
| the last row of the table is deleted. |
| Retrieve the second TABLE element and invoke the deleteRow() method |
| with an index of negative one. Currently there are four rows in the |
| table. The deleteRow() method is called and now there should be three. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-11-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-13114938"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="table" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""table""/> |
| <assertSize collection="nodeList" size="3" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="4" id="rowsLink1" ignoreCase="false"/> |
| <deleteRow interface="HTMLTableElement" obj="testNode" index="-1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="3" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableRowElement15.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableRowElement15"> |
| <metadata> |
| <title>HTMLTableRowElement15</title> |
| <creator>NIST</creator> |
| <description> |
| The insertCell() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is greater than the number of cells. |
| Retrieve the fourth TR element which has six cells. Try |
| to insert a cell using an index of seven. This should throw |
| a INDEX_SIZE_ERR DOMException since there are only six cells. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-68927016"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-68927016')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newCell" type="HTMLElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <assertDOMException id="HTMLTableRowElement15"> |
| <INDEX_SIZE_ERR> |
| <insertCell interface="HTMLTableRowElement" obj="testNode" var="newCell" index="7"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableRowElement16.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableRowElement16"> |
| <metadata> |
| <title>HTMLTableRowElement16</title> |
| <creator>NIST</creator> |
| <description> |
| The insertCell() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is negative. |
| Retrieve the fourth TR element which has six cells. Try |
| to insert a cell using an index of negative seven. This should throw |
| a INDEX_SIZE_ERR DOMException since the index is negative. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-68927016"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-68927016')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newCell" type="HTMLElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <assertDOMException id="HTMLTableRowElement16"> |
| <INDEX_SIZE_ERR> |
| <insertCell interface="HTMLTableRowElement" obj="testNode" var="newCell" index="-7"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableRowElement17.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableRowElement17"> |
| <metadata> |
| <title>HTMLTableRowElement17</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteCell() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is greater than the number of cells. |
| Retrieve the fourth TR element which has six cells. Try |
| to delete a cell using an index of seven. This should throw |
| a INDEX_SIZE_ERR DOMException since there are only six cells. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-11738598"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-11738598')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <assertDOMException id="HTMLTableRowElement17"> |
| <INDEX_SIZE_ERR> |
| <deleteCell interface="HTMLTableRowElement" obj="testNode" index="7"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableRowElement18.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableRowElement18"> |
| <metadata> |
| <title>HTMLTableRowElement18</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteCell() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is equal to the number of cells. |
| Retrieve the fourth TR element which has six cells. Try |
| to delete a cell using an index of six. This should throw |
| a INDEX_SIZE_ERR DOMException since there are only six cells. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-11738598"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-11738598')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <assertDOMException id="HTMLTableRowElement18"> |
| <INDEX_SIZE_ERR> |
| <deleteCell interface="HTMLTableRowElement" obj="testNode" index="6"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableRowElement19.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableRowElement19"> |
| <metadata> |
| <title>HTMLTableRowElement19</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteCell() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is negative. |
| Retrieve the fourth TR element which has six cells. Try |
| to delete a cell using an index of negative six. This should throw |
| a INDEX_SIZE_ERR DOMException since the index is negative. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-11738598"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-11738598')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"tr"'/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <assertDOMException id="HTMLTableRowElement19"> |
| <INDEX_SIZE_ERR> |
| <deleteCell interface="HTMLTableRowElement" obj="testNode" index="-6"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableRowElement20.xml |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableRowElement20"> |
| <metadata> |
| <title>HTMLTableRowElement20</title> |
| <creator>NIST</creator> |
| <description> |
| The insertCell() method inserts an empty TD cell into this row. |
| If index is -1 or equal to the number of cells, the new cell is |
| appended. |
| Retrieve the fourth TR element and examine the value of |
| the cells length attribute which should be set to six. |
| Check the value of the last TD element. Invoke the |
| insertCell() with an index of negative one |
| which will append the empty cell to the end of the list. |
| Check the value of the newly created cell and make sure it is null |
| and also the numbers of cells should now be seven. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-11-07</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-68927016"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="cellsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="trNode" type="Node"/> |
| <var name="cellNode" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <var name="newCell" type="HTMLElement"/> |
| <var name="vcells" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""tr""/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="6" id="cellsLink1" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="5"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <nodeValue obj="cellNode" var="value"/> |
| <assertEquals actual="value" expected=""1230 North Ave. Dallas, Texas 98551"" id="value1Link" ignoreCase="false"/> |
| <insertCell interface="HTMLTableRowElement" obj="testNode" var="newCell" index="-1"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="7" id="cellsLink2" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="6"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <assertNull actual="cellNode" id="value2Link"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableRowElement21.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableRowElement21"> |
| <metadata> |
| <title>HTMLTableRowElement21</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteCell() method deletes a cell from the currtent row. If |
| the index is -1 the last cell in the row is deleted. |
| Retrieve the fourth TR element and examine the value of |
| the cells length attribute which should be set to six. |
| Check the value of the last TD element. Invoke the |
| deleteCell() with an index of negative one |
| which will delete the last cell in the row. |
| Check the value of the of the last cell |
| and also the numbers of cells should now be five. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-11-07</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-11738598"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="cellsnodeList" type="HTMLCollection"/> |
| <var name="testNode" type="Node"/> |
| <var name="trNode" type="Node"/> |
| <var name="cellNode" type="Node"/> |
| <var name="value" type="DOMString"/> |
| <var name="vcells" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablerow" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""tr""/> |
| <assertSize collection="nodeList" size="5" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="6" id="cellsLink1" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="5"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <nodeValue obj="cellNode" var="value"/> |
| <assertEquals actual="value" expected=""1230 North Ave. Dallas, Texas 98551"" id="value1Link" ignoreCase="false"/> |
| <deleteCell interface="HTMLTableRowElement" obj="testNode" index="-1"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="3"/> |
| <cells interface="HTMLTableRowElement" obj="testNode" var="cellsnodeList"/> |
| <length interface="HTMLCollection" obj="cellsnodeList" var="vcells"/> |
| <assertEquals actual="vcells" expected="5" id="cellsLink2" ignoreCase="false"/> |
| <item interface="HTMLCollection" obj="cellsnodeList" var="trNode" index="4"/> |
| <firstChild interface="Node" obj="trNode" var="cellNode"/> |
| <nodeValue obj="cellNode" var="value"/> |
| <assertEquals actual="value" expected='"Female"' id="value2Link" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableSectionElement25.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableSectionElement25"> |
| <metadata> |
| <title>HTMLTableSectionElement25</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is greater than the number of rows. |
| Retrieve the first THEAD element which has one row. Try |
| to insert a new row using an index of two. This should throw |
| a INDEX_SIZE_ERR DOMException since there is only one row. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-93995626"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-93995626')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <assertDOMException id="HTMLTableSectionElement25"> |
| <INDEX_SIZE_ERR> |
| <insertRow interface="HTMLTableSectionElement" obj="testNode" var="newRow" index="2"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableSectionElement26.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableSectionElement26"> |
| <metadata> |
| <title>HTMLTableSectionElement26</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is negative. |
| Retrieve the first THEAD element which has one row. Try |
| to insert a new row using an index of negative two. This should throw |
| a INDEX_SIZE_ERR DOMException since the index is negative. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-93995626"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-93995626')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <assertDOMException id="HTMLTableSectionElement26"> |
| <INDEX_SIZE_ERR> |
| <insertRow interface="HTMLTableSectionElement" obj="testNode" var="newRow" index="-2"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableSectionElement27.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableSectionElement27"> |
| <metadata> |
| <title>HTMLTableSectionElement27</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is greater than the number of rows. |
| Retrieve the first THEAD element which has one row. Try |
| to delete a row using an index of two. This should throw |
| a INDEX_SIZE_ERR DOMException since the index is greater than the |
| number of rows. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-5625626"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-5625626')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <assertDOMException id="HTMLTableSectionElement27"> |
| <INDEX_SIZE_ERR> |
| <deleteRow interface="HTMLTableSectionElement" obj="testNode" index="2"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableSectionElement28.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableSectionElement28"> |
| <metadata> |
| <title>HTMLTableSectionElement28</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is equal to the number of rows. |
| Retrieve the first THEAD element which has one row. Try |
| to delete a row using an index of 1. This should throw |
| a INDEX_SIZE_ERR DOMException since the index is equal to the |
| number of rows. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-5625626"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-5625626')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <assertDOMException id="HTMLTableSectionElement28"> |
| <INDEX_SIZE_ERR> |
| <deleteRow interface="HTMLTableSectionElement" obj="testNode" index="1"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableSectionElement29.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableSectionElement29"> |
| <metadata> |
| <title>HTMLTableSectionElement29</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method throws a INDEX_SIZE_ERR DOMException |
| if the specified index is negative. |
| Retrieve the first THEAD element which has one row. Try |
| to delete a row using an index of negative two. This should throw |
| a INDEX_SIZE_ERR DOMException since the index is negative. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-05-02</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-5625626"/> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#xpointer(id('ID-5625626')/raises/exception[@name='DOMException']/descr/p[substring-before(.,':')='INDEX_SIZE_ERR'])"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"thead"'/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <assertDOMException id="HTMLTableSectionElement29"> |
| <INDEX_SIZE_ERR> |
| <deleteRow interface="HTMLTableSectionElement" obj="testNode" index="-2"/> |
| </INDEX_SIZE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableSectionElement30.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableSectionElement30"> |
| <metadata> |
| <title>HTMLTableSectionElement30</title> |
| <creator>NIST</creator> |
| <description> |
| The insertRow() method inserts a new empty table row. The new |
| row is inserted immediately before the current indexth row in this |
| section. If index is -1 or equal to the number of rows in this section, |
| the new row is appended. |
| Retrieve the first THEAD element and invoke the insertRow() method |
| with an index of negative one. Since the index is negative one the |
| new row is appended. |
| After the new row is appended the number of rows in the THEAD |
| section is two. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-11-07</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-93995626"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="newRow" type="HTMLElement"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""thead""/> |
| <assertSize collection="nodeList" size="1" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink1" ignoreCase="false"/> |
| <insertRow interface="HTMLTableSectionElement" obj="testNode" var="newRow" index="-1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/HTMLTableSectionElement31.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="HTMLTableSectionElement31"> |
| <metadata> |
| <title>HTMLTableSectionElement31</title> |
| <creator>NIST</creator> |
| <description> |
| The deleteRow() method deletes a row from this section. The index |
| starts from 0 and is relative only to the rows contained inside |
| this section, not all the rows in the table. If the index is -1 |
| the last row will be deleted. |
| Retrieve the second TBODY element and invoke the deleteRow() method |
| with an index of -1. The nuber of rows in the THEAD section before |
| the deletion of the row is two. After the row is deleted the number |
| of rows in the TBODY section is one. |
| </description> |
| <contributor>Rick Rivello</contributor> |
| <date qualifier="created">2002-11-07</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-5625626"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="rowsnodeList" type="HTMLCollection"/> |
| <var name="vrows" type="int"/> |
| <var name="doc" type="Document"/> |
| <load var="doc" href="tablesection" willBeModified="true"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname=""tbody""/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="2" id="rowsLink1" ignoreCase="false"/> |
| <deleteRow interface="HTMLTableSectionElement" obj="testNode" index="-1"/> |
| <rows interface="HTMLTableSectionElement" obj="testNode" var="rowsnodeList"/> |
| <length interface="HTMLCollection" obj="rowsnodeList" var="vrows"/> |
| <assertEquals actual="vrows" expected="1" id="rowsLink2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/alltests.xml |
|---|
| 0,0 → 1,707 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE suite SYSTEM "dom2.dtd"> |
| <suite xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="alltests"> |
| <metadata> |
| <title>DOM Level 2 HTML Test Suite</title> |
| <creator>DOM Test Suite Project</creator> |
| </metadata> |
| <suite.member href="../../level1/html/HTMLAnchorElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement13.xml"/> |
| <suite.member href="../../level1/html/HTMLAnchorElement14.xml"/> |
| <suite.member href="../../level1/html/HTMLAppletElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLAppletElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLAppletElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLAppletElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLAppletElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLAppletElement06.xml"/> |
| <suite.member href="HTMLAppletElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLAppletElement08.xml"/> |
| <suite.member href="HTMLAppletElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLAppletElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLAppletElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLAreaElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLAreaElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLAreaElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLAreaElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLAreaElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLAreaElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLAreaElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLAreaElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLBRElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLBaseElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLBaseElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLBaseFontElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLBaseFontElement02.xml"/> |
| <suite.member href="HTMLBaseFontElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLBodyElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLBodyElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLBodyElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLBodyElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLBodyElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLBodyElement06.xml"/> |
| <suite.member href="HTMLBodyElement07.xml"/> |
| <suite.member href="HTMLBodyElement08.xml"/> |
| <suite.member href="HTMLBodyElement09.xml"/> |
| <suite.member href="HTMLBodyElement10.xml"/> |
| <suite.member href="HTMLBodyElement11.xml"/> |
| <suite.member href="HTMLBodyElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLButtonElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLButtonElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLButtonElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLButtonElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLButtonElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLButtonElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLButtonElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLButtonElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection01.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection02.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection03.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection04.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection05.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection06.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection07.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection08.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection09.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection10.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection11.xml"/> |
| <suite.member href="../../level1/html/HTMLCollection12.xml"/> |
| <suite.member href="../../level1/html/HTMLDirectoryElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLDivElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLDlistElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument01.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument02.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument03.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument04.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument05.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument07.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument08.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument09.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument10.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument11.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument12.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument13.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument14.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument15.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument16.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument17.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument18.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument19.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument20.xml"/> |
| <suite.member href="../../level1/html/HTMLDocument21.xml"/> |
| <suite.member href="HTMLDocument22.xml"/> |
| <suite.member href="HTMLDocument23.xml"/> |
| <suite.member href="HTMLDocument24.xml"/> |
| <suite.member href="HTMLDocument25.xml"/> |
| <suite.member href="HTMLDocument26.xml"/> |
| <suite.member href="HTMLDocument27.xml"/> |
| <suite.member href="../../level1/html/HTMLElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLElement100.xml"/> |
| <suite.member href="../../level1/html/HTMLElement101.xml"/> |
| <suite.member href="../../level1/html/HTMLElement102.xml"/> |
| <suite.member href="../../level1/html/HTMLElement103.xml"/> |
| <suite.member href="../../level1/html/HTMLElement104.xml"/> |
| <suite.member href="../../level1/html/HTMLElement105.xml"/> |
| <suite.member href="../../level1/html/HTMLElement106.xml"/> |
| <suite.member href="../../level1/html/HTMLElement107.xml"/> |
| <suite.member href="../../level1/html/HTMLElement108.xml"/> |
| <suite.member href="../../level1/html/HTMLElement109.xml"/> |
| <suite.member href="../../level1/html/HTMLElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLElement110.xml"/> |
| <suite.member href="../../level1/html/HTMLElement111.xml"/> |
| <suite.member href="../../level1/html/HTMLElement112.xml"/> |
| <suite.member href="../../level1/html/HTMLElement113.xml"/> |
| <suite.member href="../../level1/html/HTMLElement114.xml"/> |
| <suite.member href="../../level1/html/HTMLElement115.xml"/> |
| <suite.member href="../../level1/html/HTMLElement116.xml"/> |
| <suite.member href="../../level1/html/HTMLElement117.xml"/> |
| <suite.member href="../../level1/html/HTMLElement118.xml"/> |
| <suite.member href="../../level1/html/HTMLElement119.xml"/> |
| <suite.member href="../../level1/html/HTMLElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLElement120.xml"/> |
| <suite.member href="../../level1/html/HTMLElement121.xml"/> |
| <suite.member href="../../level1/html/HTMLElement122.xml"/> |
| <suite.member href="../../level1/html/HTMLElement123.xml"/> |
| <suite.member href="../../level1/html/HTMLElement124.xml"/> |
| <suite.member href="../../level1/html/HTMLElement125.xml"/> |
| <suite.member href="../../level1/html/HTMLElement126.xml"/> |
| <suite.member href="../../level1/html/HTMLElement127.xml"/> |
| <suite.member href="../../level1/html/HTMLElement128.xml"/> |
| <suite.member href="../../level1/html/HTMLElement129.xml"/> |
| <suite.member href="../../level1/html/HTMLElement13.xml"/> |
| <suite.member href="../../level1/html/HTMLElement130.xml"/> |
| <suite.member href="../../level1/html/HTMLElement131.xml"/> |
| <suite.member href="../../level1/html/HTMLElement132.xml"/> |
| <suite.member href="../../level1/html/HTMLElement133.xml"/> |
| <suite.member href="../../level1/html/HTMLElement134.xml"/> |
| <suite.member href="../../level1/html/HTMLElement135.xml"/> |
| <suite.member href="../../level1/html/HTMLElement136.xml"/> |
| <suite.member href="../../level1/html/HTMLElement137.xml"/> |
| <suite.member href="../../level1/html/HTMLElement138.xml"/> |
| <suite.member href="../../level1/html/HTMLElement139.xml"/> |
| <suite.member href="../../level1/html/HTMLElement14.xml"/> |
| <suite.member href="../../level1/html/HTMLElement140.xml"/> |
| <suite.member href="../../level1/html/HTMLElement141.xml"/> |
| <suite.member href="../../level1/html/HTMLElement142.xml"/> |
| <suite.member href="../../level1/html/HTMLElement143.xml"/> |
| <suite.member href="../../level1/html/HTMLElement144.xml"/> |
| <suite.member href="../../level1/html/HTMLElement145.xml"/> |
| <suite.member href="../../level1/html/HTMLElement15.xml"/> |
| <suite.member href="../../level1/html/HTMLElement16.xml"/> |
| <suite.member href="../../level1/html/HTMLElement17.xml"/> |
| <suite.member href="../../level1/html/HTMLElement18.xml"/> |
| <suite.member href="../../level1/html/HTMLElement19.xml"/> |
| <suite.member href="../../level1/html/HTMLElement20.xml"/> |
| <suite.member href="../../level1/html/HTMLElement21.xml"/> |
| <suite.member href="../../level1/html/HTMLElement22.xml"/> |
| <suite.member href="../../level1/html/HTMLElement23.xml"/> |
| <suite.member href="../../level1/html/HTMLElement24.xml"/> |
| <suite.member href="../../level1/html/HTMLElement25.xml"/> |
| <suite.member href="../../level1/html/HTMLElement26.xml"/> |
| <suite.member href="../../level1/html/HTMLElement27.xml"/> |
| <suite.member href="../../level1/html/HTMLElement28.xml"/> |
| <suite.member href="../../level1/html/HTMLElement29.xml"/> |
| <suite.member href="../../level1/html/HTMLElement30.xml"/> |
| <suite.member href="../../level1/html/HTMLElement31.xml"/> |
| <suite.member href="../../level1/html/HTMLElement32.xml"/> |
| <suite.member href="../../level1/html/HTMLElement33.xml"/> |
| <suite.member href="../../level1/html/HTMLElement34.xml"/> |
| <suite.member href="../../level1/html/HTMLElement35.xml"/> |
| <suite.member href="../../level1/html/HTMLElement36.xml"/> |
| <suite.member href="../../level1/html/HTMLElement37.xml"/> |
| <suite.member href="../../level1/html/HTMLElement38.xml"/> |
| <suite.member href="../../level1/html/HTMLElement39.xml"/> |
| <suite.member href="../../level1/html/HTMLElement40.xml"/> |
| <suite.member href="../../level1/html/HTMLElement41.xml"/> |
| <suite.member href="../../level1/html/HTMLElement42.xml"/> |
| <suite.member href="../../level1/html/HTMLElement43.xml"/> |
| <suite.member href="../../level1/html/HTMLElement44.xml"/> |
| <suite.member href="../../level1/html/HTMLElement45.xml"/> |
| <suite.member href="../../level1/html/HTMLElement46.xml"/> |
| <suite.member href="../../level1/html/HTMLElement47.xml"/> |
| <suite.member href="../../level1/html/HTMLElement48.xml"/> |
| <suite.member href="../../level1/html/HTMLElement49.xml"/> |
| <suite.member href="../../level1/html/HTMLElement50.xml"/> |
| <suite.member href="../../level1/html/HTMLElement51.xml"/> |
| <suite.member href="../../level1/html/HTMLElement52.xml"/> |
| <suite.member href="../../level1/html/HTMLElement53.xml"/> |
| <suite.member href="../../level1/html/HTMLElement54.xml"/> |
| <suite.member href="../../level1/html/HTMLElement55.xml"/> |
| <suite.member href="../../level1/html/HTMLElement56.xml"/> |
| <suite.member href="../../level1/html/HTMLElement57.xml"/> |
| <suite.member href="../../level1/html/HTMLElement58.xml"/> |
| <suite.member href="../../level1/html/HTMLElement59.xml"/> |
| <suite.member href="../../level1/html/HTMLElement60.xml"/> |
| <suite.member href="../../level1/html/HTMLElement61.xml"/> |
| <suite.member href="../../level1/html/HTMLElement62.xml"/> |
| <suite.member href="../../level1/html/HTMLElement63.xml"/> |
| <suite.member href="../../level1/html/HTMLElement64.xml"/> |
| <suite.member href="../../level1/html/HTMLElement65.xml"/> |
| <suite.member href="../../level1/html/HTMLElement66.xml"/> |
| <suite.member href="../../level1/html/HTMLElement67.xml"/> |
| <suite.member href="../../level1/html/HTMLElement68.xml"/> |
| <suite.member href="../../level1/html/HTMLElement69.xml"/> |
| <suite.member href="../../level1/html/HTMLElement70.xml"/> |
| <suite.member href="../../level1/html/HTMLElement71.xml"/> |
| <suite.member href="../../level1/html/HTMLElement72.xml"/> |
| <suite.member href="../../level1/html/HTMLElement73.xml"/> |
| <suite.member href="../../level1/html/HTMLElement74.xml"/> |
| <suite.member href="../../level1/html/HTMLElement75.xml"/> |
| <suite.member href="../../level1/html/HTMLElement76.xml"/> |
| <suite.member href="../../level1/html/HTMLElement77.xml"/> |
| <suite.member href="../../level1/html/HTMLElement78.xml"/> |
| <suite.member href="../../level1/html/HTMLElement79.xml"/> |
| <suite.member href="../../level1/html/HTMLElement80.xml"/> |
| <suite.member href="../../level1/html/HTMLElement81.xml"/> |
| <suite.member href="../../level1/html/HTMLElement82.xml"/> |
| <suite.member href="../../level1/html/HTMLElement83.xml"/> |
| <suite.member href="../../level1/html/HTMLElement84.xml"/> |
| <suite.member href="../../level1/html/HTMLElement85.xml"/> |
| <suite.member href="../../level1/html/HTMLElement86.xml"/> |
| <suite.member href="../../level1/html/HTMLElement87.xml"/> |
| <suite.member href="../../level1/html/HTMLElement88.xml"/> |
| <suite.member href="../../level1/html/HTMLElement89.xml"/> |
| <suite.member href="../../level1/html/HTMLElement90.xml"/> |
| <suite.member href="../../level1/html/HTMLElement91.xml"/> |
| <suite.member href="../../level1/html/HTMLElement92.xml"/> |
| <suite.member href="../../level1/html/HTMLElement93.xml"/> |
| <suite.member href="../../level1/html/HTMLElement94.xml"/> |
| <suite.member href="../../level1/html/HTMLElement95.xml"/> |
| <suite.member href="../../level1/html/HTMLElement96.xml"/> |
| <suite.member href="../../level1/html/HTMLElement97.xml"/> |
| <suite.member href="../../level1/html/HTMLElement98.xml"/> |
| <suite.member href="../../level1/html/HTMLElement99.xml"/> |
| <suite.member href="../../level1/html/HTMLFieldSetElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLFieldSetElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLFontElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLFontElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLFontElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLFormElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLFormElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLFormElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLFormElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLFormElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLFormElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLFormElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLFormElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLFormElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLFormElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLFrameElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLFrameElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLFrameElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLFrameElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLFrameElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLFrameElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLFrameElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLFrameElement08.xml"/> |
| <suite.member href="HTMLFrameElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLFrameSetElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLFrameSetElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLHRElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLHRElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLHRElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLHRElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLHeadElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLHeadingElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLHeadingElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLHeadingElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLHeadingElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLHeadingElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLHeadingElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLHtmlElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLIFrameElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLIFrameElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLIFrameElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLIFrameElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLIFrameElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLIFrameElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLIFrameElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLIFrameElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLIFrameElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLIFrameElement10.xml"/> |
| <suite.member href="HTMLIFrameElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLImageElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLImageElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLImageElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLImageElement04.xml"/> |
| <suite.member href="HTMLImageElement05.xml"/> |
| <suite.member href="HTMLImageElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLImageElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLImageElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLImageElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLImageElement10.xml"/> |
| <suite.member href="HTMLImageElement11.xml"/> |
| <suite.member href="HTMLImageElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement12.xml"/> |
| <suite.member href="HTMLInputElement13.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement14.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement15.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement16.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement17.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement18.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement19.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement20.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement21.xml"/> |
| <suite.member href="../../level1/html/HTMLInputElement22.xml"/> |
| <suite.member href="../../level1/html/HTMLIsIndexElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLIsIndexElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLIsIndexElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLLIElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLLIElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLLabelElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLLabelElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLLabelElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLLabelElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLLegendElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLLegendElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLLegendElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLLegendElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLLinkElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLLinkElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLLinkElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLLinkElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLLinkElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLLinkElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLLinkElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLLinkElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLLinkElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLMapElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLMapElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLMenuElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLMetaElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLMetaElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLMetaElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLMetaElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLModElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLModElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLModElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLModElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLOListElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLOListElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLOListElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement10.xml"/> |
| <suite.member href="HTMLObjectElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement13.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement14.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement15.xml"/> |
| <suite.member href="HTMLObjectElement16.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement17.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement18.xml"/> |
| <suite.member href="../../level1/html/HTMLObjectElement19.xml"/> |
| <suite.member href="HTMLObjectElement20.xml"/> |
| <suite.member href="../../level1/html/HTMLOptGroupElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLOptGroupElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLOptionElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLOptionElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLOptionElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLOptionElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLOptionElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLOptionElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLOptionElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLOptionElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLOptionElement09.xml"/> |
| <suite.member href="HTMLOptionsCollection01.xml"/> |
| <suite.member href="HTMLOptionsCollection02.xml"/> |
| <suite.member href="HTMLOptionsCollection03.xml"/> |
| <suite.member href="HTMLOptionsCollection04.xml"/> |
| <suite.member href="HTMLOptionsCollection05.xml"/> |
| <suite.member href="HTMLOptionsCollection06.xml"/> |
| <suite.member href="HTMLOptionsCollection07.xml"/> |
| <suite.member href="../../level1/html/HTMLParagraphElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLParamElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLParamElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLParamElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLParamElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLPreElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLQuoteElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLQuoteElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLScriptElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLScriptElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLScriptElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLScriptElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLScriptElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLScriptElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLScriptElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement13.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement14.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement15.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement16.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement17.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement18.xml"/> |
| <suite.member href="../../level1/html/HTMLSelectElement19.xml"/> |
| <suite.member href="HTMLSelectElement20.xml"/> |
| <suite.member href="../../level1/html/HTMLStyleElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLStyleElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLStyleElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCaptionElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement13.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement14.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement15.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement16.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement17.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement18.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement19.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement20.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement21.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement22.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement23.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement24.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement25.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement26.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement27.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement28.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement29.xml"/> |
| <suite.member href="../../level1/html/HTMLTableCellElement30.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLTableColElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement13.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement14.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement15.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement16.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement17.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement18.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement19.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement20.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement21.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement22.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement23.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement24.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement25.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement26.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement27.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement28.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement29.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement30.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement31.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement32.xml"/> |
| <suite.member href="../../level1/html/HTMLTableElement33.xml"/> |
| <suite.member href="HTMLTableElement34.xml"/> |
| <suite.member href="HTMLTableElement35.xml"/> |
| <suite.member href="HTMLTableElement36.xml"/> |
| <suite.member href="HTMLTableElement37.xml"/> |
| <suite.member href="HTMLTableElement38.xml"/> |
| <suite.member href="HTMLTableElement39.xml"/> |
| <suite.member href="HTMLTableElement40.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement13.xml"/> |
| <suite.member href="../../level1/html/HTMLTableRowElement14.xml"/> |
| <suite.member href="HTMLTableRowElement15.xml"/> |
| <suite.member href="HTMLTableRowElement16.xml"/> |
| <suite.member href="HTMLTableRowElement17.xml"/> |
| <suite.member href="HTMLTableRowElement18.xml"/> |
| <suite.member href="HTMLTableRowElement19.xml"/> |
| <suite.member href="HTMLTableRowElement20.xml"/> |
| <suite.member href="HTMLTableRowElement21.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement13.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement14.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement15.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement16.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement17.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement18.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement19.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement20.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement21.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement22.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement23.xml"/> |
| <suite.member href="../../level1/html/HTMLTableSectionElement24.xml"/> |
| <suite.member href="HTMLTableSectionElement25.xml"/> |
| <suite.member href="HTMLTableSectionElement26.xml"/> |
| <suite.member href="HTMLTableSectionElement27.xml"/> |
| <suite.member href="HTMLTableSectionElement28.xml"/> |
| <suite.member href="HTMLTableSectionElement29.xml"/> |
| <suite.member href="HTMLTableSectionElement30.xml"/> |
| <suite.member href="HTMLTableSectionElement31.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement02.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement03.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement04.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement05.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement06.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement07.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement08.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement09.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement10.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement11.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement12.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement13.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement14.xml"/> |
| <suite.member href="../../level1/html/HTMLTextAreaElement15.xml"/> |
| <suite.member href="../../level1/html/HTMLTitleElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLUListElement01.xml"/> |
| <suite.member href="../../level1/html/HTMLUListElement02.xml"/> |
| <suite.member href="../../level1/html/anchor01.xml"/> |
| <suite.member href="../../level1/html/anchor02.xml"/> |
| <suite.member href="../../level1/html/anchor03.xml"/> |
| <suite.member href="../../level1/html/anchor04.xml"/> |
| <suite.member href="../../level1/html/anchor05.xml"/> |
| <suite.member href="../../level1/html/anchor06.xml"/> |
| <suite.member href="../../level1/html/area01.xml"/> |
| <suite.member href="../../level1/html/area02.xml"/> |
| <suite.member href="../../level1/html/area03.xml"/> |
| <suite.member href="../../level1/html/area04.xml"/> |
| <suite.member href="../../level1/html/basefont01.xml"/> |
| <suite.member href="../../level1/html/body01.xml"/> |
| <suite.member href="../../level1/html/button01.xml"/> |
| <suite.member href="../../level1/html/button02.xml"/> |
| <suite.member href="../../level1/html/button03.xml"/> |
| <suite.member href="../../level1/html/button04.xml"/> |
| <suite.member href="../../level1/html/button05.xml"/> |
| <suite.member href="../../level1/html/button06.xml"/> |
| <suite.member href="../../level1/html/button07.xml"/> |
| <suite.member href="../../level1/html/button08.xml"/> |
| <suite.member href="../../level1/html/button09.xml"/> |
| <suite.member href="../../level1/html/dlist01.xml"/> |
| <suite.member href="../../level1/html/doc01.xml"/> |
| <suite.member href="../../level1/html/hasFeature01.xml"/> |
| <suite.member href="hasFeature02.xml"/> |
| <suite.member href="hasFeature03.xml"/> |
| <suite.member href="hasFeature04.xml"/> |
| <suite.member href="hasFeature05.xml"/> |
| <suite.member href="hasFeature06.xml"/> |
| <suite.member href="../../level1/html/object01.xml"/> |
| <suite.member href="../../level1/html/object02.xml"/> |
| <suite.member href="../../level1/html/object03.xml"/> |
| <suite.member href="../../level1/html/object04.xml"/> |
| <suite.member href="../../level1/html/object05.xml"/> |
| <suite.member href="../../level1/html/object06.xml"/> |
| <suite.member href="../../level1/html/object07.xml"/> |
| <suite.member href="object08.xml"/> |
| <suite.member href="../../level1/html/object09.xml"/> |
| <suite.member href="../../level1/html/object10.xml"/> |
| <suite.member href="../../level1/html/object11.xml"/> |
| <suite.member href="../../level1/html/object12.xml"/> |
| <suite.member href="object13.xml"/> |
| <suite.member href="../../level1/html/object14.xml"/> |
| <suite.member href="../../level1/html/object15.xml"/> |
| <suite.member href="../../level1/html/table01.xml"/> |
| <suite.member href="../../level1/html/table02.xml"/> |
| <suite.member href="../../level1/html/table03.xml"/> |
| <suite.member href="../../level1/html/table04.xml"/> |
| <suite.member href="../../level1/html/table06.xml"/> |
| <suite.member href="../../level1/html/table07.xml"/> |
| <suite.member href="../../level1/html/table08.xml"/> |
| <suite.member href="../../level1/html/table09.xml"/> |
| <suite.member href="../../level1/html/table10.xml"/> |
| <suite.member href="../../level1/html/table12.xml"/> |
| <suite.member href="../../level1/html/table15.xml"/> |
| <suite.member href="../../level1/html/table17.xml"/> |
| <suite.member href="../../level1/html/table18.xml"/> |
| <suite.member href="../../level1/html/table19.xml"/> |
| <suite.member href="../../level1/html/table20.xml"/> |
| <suite.member href="../../level1/html/table21.xml"/> |
| <suite.member href="../../level1/html/table22.xml"/> |
| <suite.member href="../../level1/html/table23.xml"/> |
| <suite.member href="../../level1/html/table24.xml"/> |
| <suite.member href="../../level1/html/table25.xml"/> |
| <suite.member href="../../level1/html/table26.xml"/> |
| <suite.member href="../../level1/html/table27.xml"/> |
| <suite.member href="../../level1/html/table28.xml"/> |
| <suite.member href="../../level1/html/table29.xml"/> |
| <suite.member href="../../level1/html/table30.xml"/> |
| <suite.member href="../../level1/html/table31.xml"/> |
| <suite.member href="../../level1/html/table32.xml"/> |
| <suite.member href="../../level1/html/table33.xml"/> |
| <suite.member href="../../level1/html/table34.xml"/> |
| <suite.member href="../../level1/html/table35.xml"/> |
| <suite.member href="../../level1/html/table36.xml"/> |
| <suite.member href="../../level1/html/table37.xml"/> |
| <suite.member href="../../level1/html/table38.xml"/> |
| <suite.member href="../../level1/html/table39.xml"/> |
| <suite.member href="../../level1/html/table40.xml"/> |
| <suite.member href="../../level1/html/table41.xml"/> |
| <suite.member href="../../level1/html/table42.xml"/> |
| <suite.member href="../../level1/html/table43.xml"/> |
| <suite.member href="../../level1/html/table44.xml"/> |
| <suite.member href="../../level1/html/table45.xml"/> |
| <suite.member href="../../level1/html/table46.xml"/> |
| <suite.member href="../../level1/html/table47.xml"/> |
| <suite.member href="../../level1/html/table48.xml"/> |
| <suite.member href="../../level1/html/table49.xml"/> |
| <suite.member href="../../level1/html/table50.xml"/> |
| <suite.member href="../../level1/html/table51.xml"/> |
| <suite.member href="../../level1/html/table52.xml"/> |
| <suite.member href="../../level1/html/table53.xml"/> |
| </suite> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/.cvsignore |
|---|
| 0,0 → 1,6 |
| xhtml1-frameset.dtd |
| xhtml1-strict.dtd |
| xhtml1-transitional.dtd |
| xhtml-lat1.ent |
| xhtml-special.ent |
| xhtml-symbol.ent |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/CVS/Entries |
|---|
| 0,0 → 1,11 |
| /.cvsignore/1.1/Fri Apr 3 02:47:56 2009// |
| /frame2.html/1.3/Fri Apr 3 02:47:56 2009// |
| /frame2.xhtml/1.4/Fri Apr 3 02:47:56 2009/-kb/ |
| /frame2.xml/1.4/Fri Apr 3 02:47:55 2009// |
| /iframe2.html/1.4/Fri Apr 3 02:47:56 2009// |
| /iframe2.xhtml/1.4/Fri Apr 3 02:47:56 2009/-kb/ |
| /iframe2.xml/1.4/Fri Apr 3 02:47:56 2009// |
| /optionscollection.html/1.2/Fri Apr 3 02:47:56 2009// |
| /optionscollection.xhtml/1.2/Fri Apr 3 02:47:56 2009/-kb/ |
| /optionscollection.xml/1.2/Fri Apr 3 02:47:56 2009// |
| D |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level2/html/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/CVS/Template |
|---|
| --- test/testcases/tests/level2/html/files/frame2.html (nonexistent) |
| +++ test/testcases/tests/level2/html/files/frame2.html (revision 4364) |
| @@ -0,0 +1,16 @@ |
| +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" |
| +"http://www.w3.org/TR/html4/frameset.dtd"> |
| +<HTML> |
| +<HEAD> |
| +<META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| +<TITLE>NIST DOM HTML Test - FRAME2</TITLE> |
| +<!-- required by frame contents --> |
| +<SCRIPT type="text/javascript">function loadComplete() { }</SCRIPT> |
| +</HEAD> |
| +<FRAMESET COLS="20, 80" onload="parent.loadComplete()"> |
| +<FRAMESET ROWS="100, 200"> |
| +<FRAME ID="Frame1" NAME="Frame1" SRC="frame.html"> |
| +</FRAMESET> |
| +<FRAME ID="Frame2" NAME="Frame2" SRC="iframe.html"> |
| +</FRAMESET> |
| +</HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/frame2.xhtml |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" |
| "xhtml1-frameset.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FRAME2</title> |
| <!-- required by frame contents --> |
| <script type="text/javascript">function loadComplete() { }</script> |
| </head> |
| <frameset cols="20, 80" onload="parent.loadComplete()"> |
| <frameset rows="100, 200"> |
| <frame id="Frame1" name="Frame1" src="frame.xhtml"/> |
| </frameset> |
| <frame id="Frame2" name="Frame2" src="iframe.xhtml"/> |
| </frameset> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/frame2.xml |
|---|
| 0,0 → 1,16 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" |
| "xhtml1-frameset.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - FRAME2</title> |
| <script type="text/javascript">function loadComplete() { }</script> |
| </head> |
| <frameset cols="20, 80" onload="parent.loadComplete()"> |
| <frameset rows="100, 200"> |
| <frame id="Frame1" name="Frame1" src="frame.html"/> |
| </frameset> |
| <frame id="Frame2" name="Frame2" src="iframe.html"/> |
| </frameset> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/iframe2.html |
|---|
| 0,0 → 1,13 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - IFRAME2</TITLE> |
| <!-- required by frame contents --> |
| <SCRIPT type="text/javascript">function loadComplete() { }</SCRIPT> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <IFRAME ID="Iframe1" NAME="Iframe1" SRC="iframe.html">IFRAME1</IFRAME> |
| <IFRAME ID="Iframe2" SRC="frame.html" NAME="Iframe2">IFRAME2</IFRAME> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/iframe2.xhtml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - IFRAME2</title> |
| <!-- required by frame contents --> |
| <script type="text/javascript">function loadComplete() { }</script> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <iframe id="Iframe1" name="Iframe1" src="iframe.html">IFRAME1</iframe> |
| <iframe id="Iframe2" src="frame.html" name="Iframe2">IFRAME2</iframe> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/iframe2.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - IFRAME2</title> |
| <!-- required by frame contents --> |
| <script type="text/javascript">function loadComplete() { }</script> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <iframe id="Iframe1" name="Iframe1" src="iframe.html">IFRAME1</iframe> |
| <iframe id="Iframe2" src="frame.html" name="Iframe2">IFRAME2</iframe> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/optionscollection.html |
|---|
| 0,0 → 1,36 |
| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <HTML> |
| <HEAD> |
| <META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=utf-8"> |
| <TITLE>NIST DOM HTML Test - OPTIONSCOLLECTION</TITLE> |
| </HEAD> |
| <BODY onload="parent.loadComplete()"> |
| <FORM ID="form1" NAME="form1" ACTION="./files/getData.pl" METHOD="post"> |
| <P> |
| <SELECT ID="selectId" DIR="ltr" TABINDEX="7" NAME="select1" MULTIPLE="multiple" SIZE="1"> |
| <OPTION SELECTED="selected" value="10001">EMP10001</OPTION> |
| <OPTION LABEL="l1">EMP10002</OPTION> |
| <OPTION>EMP10003</OPTION> |
| <OPTION>EMP10004</OPTION> |
| <OPTION>EMP10005</OPTION> |
| </SELECT> |
| </P> |
| </FORM> |
| <P> |
| <SELECT NAME="select2" disabled="disabled"> |
| <OPTION>EMP20001</OPTION> |
| <OPTION>EMP20002</OPTION> |
| <OPTION>EMP20003</OPTION> |
| <OPTION>EMP20004</OPTION> |
| <OPTION DISABLED="disabled">EMP20005</OPTION> |
| </SELECT> |
| </P> |
| </BODY> |
| </HTML> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/optionscollection.xhtml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OPTIONSCOLLECTION</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <select id="selectId" dir="ltr" tabindex="7" name="select1" multiple="multiple" size="1"> |
| <option selected="selected" value="10001">EMP10001</option> |
| <option label="l1">EMP10002</option> |
| <option>EMP10003</option> |
| <option>EMP10004</option> |
| <option>EMP10005</option> |
| </select> |
| </p> |
| </form> |
| <p> |
| <select name="select2" disabled="disabled"> |
| <option>EMP20001</option> |
| <option>EMP20002</option> |
| <option>EMP20003</option> |
| <option>EMP20004</option> |
| <option disabled="disabled">EMP20005</option> |
| </select> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/files/optionscollection.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" |
| "xhtml1-transitional.dtd"> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>NIST DOM HTML Test - OPTIONSCOLLECTION</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <form id="form1" action="./files/getData.pl" method="post"> |
| <p> |
| <select id="selectId" dir="ltr" tabindex="7" name="select1" multiple="multiple" size="1"> |
| <option selected="selected" value="10001">EMP10001</option> |
| <option label="l1">EMP10002</option> |
| <option>EMP10003</option> |
| <option>EMP10004</option> |
| <option>EMP10005</option> |
| </select> |
| </p> |
| </form> |
| <p> |
| <select name="select2" disabled="disabled"> |
| <option>EMP20001</option> |
| <option>EMP20002</option> |
| <option>EMP20003</option> |
| <option>EMP20004</option> |
| <option disabled="disabled">EMP20005</option> |
| </select> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/hasFeature02.xml |
|---|
| 0,0 → 1,31 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasFeature02"> |
| <metadata> |
| <title>hasFeature02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| hasFeature("hTmL", "2.0") should return true. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="version" type="DOMString" value='"2.0"'/> |
| <var name="state" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature obj="domImpl" var="state" feature='"hTmL"' version="version"/> |
| <assertTrue actual="state" id="hasHTML2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/hasFeature03.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasFeature03"> |
| <metadata> |
| <title>hasFeature03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| hasFeature("xhTmL", null) should return true if hasFeature("XML", null) returns true. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <var name="state" type="boolean"/> |
| <var name="hasXML" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature obj="domImpl" var="hasXML" feature='"XML"' version="version"/> |
| <hasFeature obj="domImpl" var="state" feature='"xhTmL"' version="version"/> |
| <assertEquals actual="state" expected="hasXML" ignoreCase="false" id="hasXHTML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/hasFeature04.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasFeature04"> |
| <metadata> |
| <title>hasFeature04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| hasFeature("xhTmL", "2.0") should return true if hasFeature("XML", "2.0") returns true. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="version" type="DOMString" value='"2.0"'/> |
| <var name="state" type="boolean"/> |
| <var name="hasXML" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature obj="domImpl" var="hasXML" feature='"XML"' version="version"/> |
| <hasFeature obj="domImpl" var="state" feature='"xhTmL"' version="version"/> |
| <assertEquals actual="state" expected="hasXML" ignoreCase="false" id="hasXHTML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/hasFeature05.xml |
|---|
| 0,0 → 1,31 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasFeature05"> |
| <metadata> |
| <title>hasFeature05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| hasFeature("cOrE", null) should return true. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <var name="state" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature obj="domImpl" var="state" feature='"cOrE"' version="version"/> |
| <assertTrue actual="state" id="hasCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/hasFeature06.xml |
|---|
| 0,0 → 1,31 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="hasFeature06"> |
| <metadata> |
| <title>hasFeature06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| hasFeature("cOrE", "2.0") should return true. |
| </description> |
| <date qualifier="created">2004-03-18</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-Core/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="version" type="DOMString" value='"2.0"'/> |
| <var name="state" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature obj="domImpl" var="state" feature='"cOrE"' version="version"/> |
| <assertTrue actual="state" id="hasCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/metadata.xml |
|---|
| 0,0 → 1,15 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --><!DOCTYPE metadata SYSTEM "dom2.dtd"> |
| <metadata xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2"> |
| </metadata> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/object08.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="object08"> |
| <metadata> |
| <title>object08</title> |
| <creator>Netscape</creator> |
| <description> |
| Horizontal space to the left and right of this image, applet, or object. |
| The value of attribute hspace of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-17085376"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vhspace" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <hspace interface="HTMLObjectElement" obj="testNode" var="vhspace"/> |
| <assertEquals actual="vhspace" expected='0' id="hspaceLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level2/html/object13.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2001 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom2.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2" name="object13"> |
| <metadata> |
| <title>object13</title> |
| <creator>Netscape</creator> |
| <description> |
| Vertical space above and below this image, applet, or object. |
| The value of attribute vspace of the object element is read and checked against the expected value. |
| </description> |
| <contributor>Sivakiran Tummala</contributor> |
| <date qualifier="created">2002-02-15</date> |
| <subject resource="http://www.w3.org/TR/DOM-Level-2-HTML/html#ID-8682483"/> |
| </metadata> |
| <var name="nodeList" type="NodeList"/> |
| <var name="testNode" type="Node"/> |
| <var name="vvspace" type="int" /> |
| <var name="doc" type="Node"/> |
| <load var="doc" href="object" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="nodeList" tagname='"object"'/> |
| <assertSize collection="nodeList" size="2" id="Asize"/> |
| <item interface="NodeList" obj="nodeList" var="testNode" index="0"/> |
| <vspace interface="HTMLObjectElement" obj="testNode" var="vvspace"/> |
| <assertEquals actual="vvspace" expected='0' id="vspaceLink" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/CVS/Entries |
|---|
| 0,0 → 1,5 |
| D/core//// |
| D/events//// |
| D/ls//// |
| D/validation//// |
| D/xpath//// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3 |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/CVS/Template |
|---|
| --- test/testcases/tests/level3/core/.cvsignore (nonexistent) |
| +++ test/testcases/tests/level3/core/.cvsignore (revision 4364) |
| @@ -0,0 +1,3 @@ |
| +dom3.dtd |
| +test-to-html.xsl |
| +dom3.xsd |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/CVS/Entries |
|---|
| 0,0 → 1,726 |
| D/files//// |
| /.cvsignore/1.1/Fri Apr 3 02:48:00 2009// |
| /alltests.xml/1.42/Fri Apr 3 02:47:59 2009// |
| /attrgetschematypeinfo01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /attrgetschematypeinfo02.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /attrgetschematypeinfo03.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /attrgetschematypeinfo04.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /attrgetschematypeinfo05.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /attrgetschematypeinfo06.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /attrgetschematypeinfo07.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /attrgetschematypeinfo08.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /attrisid01.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /attrisid02.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /attrisid03.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /attrisid04.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /attrisid05.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /attrisid06.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /attrisid07.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /canonicalform01.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /canonicalform02.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /canonicalform03.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /canonicalform04.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /canonicalform05.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /canonicalform06.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /canonicalform07.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /canonicalform08.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /canonicalform09.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /canonicalform10.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /canonicalform11.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /canonicalform12.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /cdatasections01.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /checkcharacternormalization01.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /checkcharacternormalization02.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /checkcharacternormalization03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /comments01.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /datatypenormalization01.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization02.xml/1.8/Fri Apr 3 02:47:59 2009// |
| /datatypenormalization03.xml/1.8/Fri Apr 3 02:48:01 2009// |
| /datatypenormalization04.xml/1.8/Fri Apr 3 02:48:00 2009// |
| /datatypenormalization05.xml/1.8/Fri Apr 3 02:48:00 2009// |
| /datatypenormalization06.xml/1.8/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization07.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /datatypenormalization08.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /datatypenormalization09.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /datatypenormalization10.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization11.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /datatypenormalization12.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /datatypenormalization13.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /datatypenormalization14.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /datatypenormalization15.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization16.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /datatypenormalization17.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /datatypenormalization18.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode01.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode02.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode03.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode04.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /documentadoptnode05.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode06.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /documentadoptnode07.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode08.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /documentadoptnode09.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /documentadoptnode10.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /documentadoptnode11.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode12.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode13.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /documentadoptnode14.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode15.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /documentadoptnode16.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /documentadoptnode17.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode18.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode19.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /documentadoptnode20.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode21.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /documentadoptnode22.xml/1.7/Fri Apr 3 02:48:01 2009// |
| /documentadoptnode23.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /documentadoptnode24.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /documentadoptnode25.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /documentadoptnode26.xml/1.8/Fri Apr 3 02:47:58 2009// |
| /documentadoptnode27.xml/1.8/Fri Apr 3 02:47:59 2009// |
| /documentadoptnode28.xml/1.7/Fri Apr 3 02:48:01 2009// |
| /documentadoptnode30.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode31.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode32.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode33.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode34.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /documentadoptnode35.xml/1.8/Fri Apr 3 02:48:00 2009// |
| /documentadoptnode36.xml/1.8/Fri Apr 3 02:47:59 2009// |
| /documentgetdoctype01.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /documentgetdocumenturi01.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /documentgetdocumenturi02.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /documentgetdocumenturi03.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /documentgetinputencoding01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /documentgetinputencoding02.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /documentgetinputencoding03.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /documentgetinputencoding04.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /documentgetstricterrorchecking01.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /documentgetstricterrorchecking02.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /documentgetxmlencoding01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /documentgetxmlencoding02.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /documentgetxmlencoding03.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /documentgetxmlencoding04.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /documentgetxmlencoding05.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /documentgetxmlstandalone01.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /documentgetxmlstandalone02.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /documentgetxmlstandalone03.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /documentgetxmlstandalone04.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /documentgetxmlstandalone05.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentgetxmlversion01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /documentgetxmlversion02.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /documentgetxmlversion03.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /documentnormalizedocument01.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /documentnormalizedocument02.xml/1.10/Fri Apr 3 02:48:00 2009// |
| /documentnormalizedocument03.xml/1.11/Fri Apr 3 02:48:01 2009// |
| /documentnormalizedocument04.xml/1.10/Fri Apr 3 02:47:58 2009// |
| /documentnormalizedocument05.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /documentnormalizedocument06.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /documentnormalizedocument07.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /documentnormalizedocument08.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /documentnormalizedocument09.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /documentnormalizedocument10.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /documentnormalizedocument11.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /documentnormalizedocument12.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /documentnormalizedocument13.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode01.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode02.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode03.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /documentrenamenode04.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /documentrenamenode05.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /documentrenamenode06.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /documentrenamenode07.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode08.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode09.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode10.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode11.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /documentrenamenode12.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode13.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /documentrenamenode14.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode15.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode16.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /documentrenamenode17.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /documentrenamenode18.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /documentrenamenode19.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode20.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /documentrenamenode21.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode22.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode23.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode24.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode25.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode26.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /documentrenamenode27.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode28.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentrenamenode29.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /documentsetdocumenturi01.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /documentsetdocumenturi02.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /documentsetdocumenturi03.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /documentsetstricterrorchecking01.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /documentsetstricterrorchecking02.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /documentsetstricterrorchecking03.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /documentsetxmlstandalone01.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /documentsetxmlstandalone02.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /documentsetxmlversion01.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /documentsetxmlversion02.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /documentsetxmlversion03.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /documentsetxmlversion05.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /domconfigcanonicalform1.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /domconfigcdatasections1.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /domconfigcheckcharacternormalization1.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /domconfigcomments1.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domconfigdatatypenormalization1.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domconfigdatatypenormalization2.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /domconfigelementcontentwhitespace1.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /domconfigentities1.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /domconfigerrorhandler1.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /domconfigerrorhandler2.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /domconfiginfoset1.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /domconfignamespacedeclarations1.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /domconfignamespaces1.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domconfignamespaces2.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /domconfignormalizecharacters1.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /domconfigparameternames01.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /domconfigschemalocation1.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /domconfigschematype1.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /domconfigsplitcdatasections1.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /domconfigurationcansetparameter01.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /domconfigurationcansetparameter02.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domconfigurationcansetparameter03.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /domconfigurationcansetparameter04.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /domconfigurationcansetparameter06.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /domconfigurationgetparameter01.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /domconfigurationgetparameter02.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /domconfigvalidate1.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /domconfigvalidateifschema1.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /domconfigwellformed1.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /domimplementationgetfeature01.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /domimplementationgetfeature02.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /domimplementationgetfeature03.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /domimplementationgetfeature05.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /domimplementationgetfeature06.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry01.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry02.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /domimplementationregistry04.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry05.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /domimplementationregistry06.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /domimplementationregistry07.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /domimplementationregistry08.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /domimplementationregistry09.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry10.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /domimplementationregistry11.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry12.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry13.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /domimplementationregistry14.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry15.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /domimplementationregistry16.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry17.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /domimplementationregistry18.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /domimplementationregistry19.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /domimplementationregistry20.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry21.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /domimplementationregistry22.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /domimplementationregistry23.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /domimplementationregistry24.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /domimplementationregistry25.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /domstringlistcontains01.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /domstringlistcontains02.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /domstringlistgetlength01.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /domstringlistitem01.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /domstringlistitem02.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /elementcontentwhitespace01.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /elementcontentwhitespace02.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /elementcontentwhitespace03.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /elementgetschematypeinfo01.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /elementgetschematypeinfo02.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /elementgetschematypeinfo03.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /elementgetschematypeinfo04.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /elementgetschematypeinfo05.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /elementgetschematypeinfo06.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /elementgetschematypeinfo07.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /elementsetidattribute01.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /elementsetidattribute03.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /elementsetidattribute04.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /elementsetidattribute05.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /elementsetidattribute06.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /elementsetidattribute07.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /elementsetidattribute08.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /elementsetidattribute09.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /elementsetidattribute10.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /elementsetidattribute11.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributenode01.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /elementsetidattributenode02.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributenode03.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributenode04.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributenode05.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributenode06.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributenode07.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /elementsetidattributenode08.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /elementsetidattributenode09.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributenode10.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributens01.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /elementsetidattributens02.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /elementsetidattributens03.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /elementsetidattributens04.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributens05.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributens06.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /elementsetidattributens07.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /elementsetidattributens08.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributens09.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /elementsetidattributens10.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributens11.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /elementsetidattributens12.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /elementsetidattributens13.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /elementsetidattributens14.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /entities01.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /entities02.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /entities03.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /entities04.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /entitygetinputencoding01.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /entitygetinputencoding02.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /entitygetinputencoding03.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /entitygetinputencoding04.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /entitygetxmlencoding01.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /entitygetxmlencoding02.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /entitygetxmlencoding03.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /entitygetxmlencoding04.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /entitygetxmlversion01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /entitygetxmlversion02.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /entitygetxmlversion03.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /entitygetxmlversion04.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /handleerror01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /handleerror02.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /hasFeature01.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /hasFeature02.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /hasFeature03.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /hasFeature04.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /infoset01.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /infoset02.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /infoset03.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /infoset04.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /infoset05.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /infoset06.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /infoset07.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /infoset08.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /infoset09.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /metadata.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /namespacedeclarations01.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /namespacedeclarations02.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /nodeappendchild01.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /nodeappendchild02.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition01.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition02.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition03.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodecomparedocumentposition04.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition05.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition06.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition07.xml/1.8/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition08.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition09.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition10.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition11.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition12.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition13.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition14.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition15.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /nodecomparedocumentposition16.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition17.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition18.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition19.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /nodecomparedocumentposition20.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition21.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodecomparedocumentposition22.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition23.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition24.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodecomparedocumentposition25.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition26.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition27.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodecomparedocumentposition28.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodecomparedocumentposition29.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition30.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodecomparedocumentposition31.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition32.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodecomparedocumentposition33.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition34.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition35.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodecomparedocumentposition36.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition37.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodecomparedocumentposition38.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodecomparedocumentposition39.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodecomparedocumentposition40.xml/1.8/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri01.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri02.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri03.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodegetbaseuri04.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodegetbaseuri05.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodegetbaseuri06.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri07.xml/1.8/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri09.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri10.xml/1.7/Fri Apr 3 02:48:01 2009// |
| /nodegetbaseuri11.xml/1.7/Fri Apr 3 02:48:01 2009// |
| /nodegetbaseuri12.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri13.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri14.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodegetbaseuri15.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri16.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri17.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /nodegetbaseuri18.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /nodegetbaseuri19.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /nodegetbaseuri20.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /nodegetfeature01.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /nodegetfeature02.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /nodegetfeature03.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /nodegetfeature04.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /nodegetfeature05.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /nodegetfeature06.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /nodegetfeature07.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /nodegetfeature08.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /nodegetfeature09.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /nodegetfeature10.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /nodegetfeature11.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /nodegetfeature12.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /nodegetfeature13.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /nodegettextcontent01.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /nodegettextcontent02.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodegettextcontent03.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /nodegettextcontent04.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodegettextcontent05.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /nodegettextcontent06.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /nodegettextcontent07.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodegettextcontent08.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodegettextcontent09.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodegettextcontent10.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodegettextcontent11.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodegettextcontent12.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodegettextcontent13.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodegettextcontent14.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodegettextcontent15.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /nodegettextcontent16.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /nodegettextcontent17.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodegettextcontent18.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /nodegettextcontent19.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /nodegetuserdata01.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /nodegetuserdata02.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /nodegetuserdata03.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodegetuserdata04.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodegetuserdata05.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodegetuserdata06.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodegetuserdata07.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodeinsertbefore01.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodeinsertbefore02.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore03.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore04.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore05.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore06.xml/1.8/Fri Apr 3 02:48:01 2009// |
| /nodeinsertbefore07.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodeinsertbefore08.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore09.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore10.xml/1.8/Fri Apr 3 02:47:58 2009// |
| /nodeinsertbefore11.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /nodeinsertbefore12.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore13.xml/1.8/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore14.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore15.xml/1.7/Fri Apr 3 02:48:01 2009// |
| /nodeinsertbefore16.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodeinsertbefore17.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore18.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /nodeinsertbefore19.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodeinsertbefore20.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodeinsertbefore21.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodeinsertbefore22.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodeinsertbefore23.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodeinsertbefore24.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodeinsertbefore25.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodeisdefaultnamespace01.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /nodeisdefaultnamespace02.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisdefaultnamespace03.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /nodeisdefaultnamespace04.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /nodeisdefaultnamespace05.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisdefaultnamespace06.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodeisdefaultnamespace07.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisdefaultnamespace08.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisdefaultnamespace09.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisdefaultnamespace10.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodeisdefaultnamespace11.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodeisdefaultnamespace13.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodeisdefaultnamespace14.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodeisdefaultnamespace15.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodeisdefaultnamespace16.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /nodeisequalnode01.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /nodeisequalnode02.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodeisequalnode03.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode04.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode05.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /nodeisequalnode06.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodeisequalnode07.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode08.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodeisequalnode09.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode10.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode11.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodeisequalnode12.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /nodeisequalnode13.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode14.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode15.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode16.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodeisequalnode17.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodeisequalnode18.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode19.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode20.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode21.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode22.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodeisequalnode25.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodeisequalnode26.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /nodeisequalnode27.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /nodeisequalnode28.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /nodeisequalnode29.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /nodeisequalnode31.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /nodeisequalnode32.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /nodeissamenode01.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /nodeissamenode02.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /nodeissamenode03.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodeissamenode04.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodeissamenode05.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /nodeissamenode06.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodeissamenode07.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /nodeissamenode08.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /nodeissamenode09.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /nodeissamenode10.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupnamespaceuri01.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /nodelookupnamespaceuri02.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodelookupnamespaceuri03.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /nodelookupnamespaceuri04.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /nodelookupnamespaceuri05.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupnamespaceuri06.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodelookupnamespaceuri07.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupnamespaceuri08.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupnamespaceuri09.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodelookupnamespaceuri10.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupnamespaceuri11.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupnamespaceuri13.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodelookupnamespaceuri14.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodelookupnamespaceuri15.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodelookupnamespaceuri16.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodelookupnamespaceuri17.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodelookupnamespaceuri18.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodelookupnamespaceuri19.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodelookupnamespaceuri20.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix01.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix02.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix03.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /nodelookupprefix04.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix05.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodelookupprefix06.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix07.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix08.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix09.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix10.xml/1.5/Fri Apr 3 02:48:01 2009// |
| /nodelookupprefix11.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodelookupprefix12.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix13.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodelookupprefix14.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodelookupprefix15.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix16.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix17.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix18.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /nodelookupprefix19.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodelookupprefix20.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /noderemovechild01.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /noderemovechild02.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /noderemovechild03.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild04.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild05.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /noderemovechild07.xml/1.7/Fri Apr 3 02:48:01 2009// |
| /noderemovechild08.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild09.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild10.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild11.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /noderemovechild12.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /noderemovechild13.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /noderemovechild14.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild15.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /noderemovechild16.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /noderemovechild17.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild18.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild19.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /noderemovechild20.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /noderemovechild21.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /noderemovechild22.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /noderemovechild23.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /noderemovechild24.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /noderemovechild25.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild26.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /noderemovechild27.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /noderemovechild28.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /noderemovechild29.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild30.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /noderemovechild31.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodereplacechild01.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /nodereplacechild02.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /nodereplacechild03.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /nodereplacechild04.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /nodereplacechild06.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild07.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodereplacechild08.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodereplacechild10.xml/1.3/Fri Apr 3 02:48:01 2009// |
| /nodereplacechild12.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /nodereplacechild13.xml/1.7/Fri Apr 3 02:48:01 2009// |
| /nodereplacechild14.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /nodereplacechild15.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodereplacechild16.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild17.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild18.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild19.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild20.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodereplacechild21.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild22.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild23.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild24.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodereplacechild25.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodereplacechild26.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild27.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /nodereplacechild28.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodereplacechild29.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild30.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /nodereplacechild31.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild32.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild33.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild34.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild35.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild36.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild37.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /nodereplacechild38.xml/1.9/Fri Apr 3 02:48:00 2009// |
| /nodereplacechild39.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /nodereplacechild40.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /nodesettextcontent01.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodesettextcontent02.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /nodesettextcontent03.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodesettextcontent04.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /nodesettextcontent05.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /nodesettextcontent06.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodesettextcontent07.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodesettextcontent08.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodesettextcontent10.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /nodesettextcontent11.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodesettextcontent12.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodesettextcontent13.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /nodesetuserdata01.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /nodesetuserdata02.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /nodesetuserdata03.xml/1.8/Fri Apr 3 02:47:58 2009// |
| /nodesetuserdata04.xml/1.8/Fri Apr 3 02:48:01 2009// |
| /nodesetuserdata05.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodesetuserdata06.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /nodesetuserdata07.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodesetuserdata08.xml/1.8/Fri Apr 3 02:48:00 2009// |
| /nodesetuserdata09.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /nodesetuserdata10.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /normalizecharacters01.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /normalizecharacters02.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /normalizecharacters03.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /normalizecharacters04.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /normalizecharacters05.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /normalizecharacters06.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /normalizecharacters07.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /normalizecharacters08.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /splitcdatasections01.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /textiselementcontentwhitespace01.xml/1.6/Fri Apr 3 02:47:59 2009// |
| /textiselementcontentwhitespace02.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /textiselementcontentwhitespace03.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /textiselementcontentwhitespace04.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /textiselementcontentwhitespace05.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /textiselementcontentwhitespace06.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /textreplacewholetext01.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /textreplacewholetext02.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /textreplacewholetext03.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /textreplacewholetext04.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /textreplacewholetext05.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /textreplacewholetext06.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /textreplacewholetext07.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /textreplacewholetext08.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /textwholetext01.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /textwholetext02.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /textwholetext03.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /typeinfogettypename03.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfogettypename04.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfogettypenamespace01.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfogettypenamespace03.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfogettypenamespace04.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom01.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom02.xml/1.7/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom03.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom04.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom05.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /typeinfoisderivedfrom06.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom07.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom08.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom09.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom10.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom11.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom12.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom13.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom14.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom15.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom16.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom17.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom18.xml/1.6/Fri Apr 3 02:48:01 2009// |
| /typeinfoisderivedfrom19.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom20.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom21.xml/1.5/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom22.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom23.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /typeinfoisderivedfrom24.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /typeinfoisderivedfrom25.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom26.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom27.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom28.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom29.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom30.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom31.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /typeinfoisderivedfrom32.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom33.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom34.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom35.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom36.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom37.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom38.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom39.xml/1.5/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom40.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom41.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom42.xml/1.4/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom43.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom44.xml/1.7/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom45.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom46.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom47.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom48.xml/1.6/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom49.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom50.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom51.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom52.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /typeinfoisderivedfrom53.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom54.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom55.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom56.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom57.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /typeinfoisderivedfrom58.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom59.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom60.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom61.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom62.xml/1.2/Fri Apr 3 02:48:01 2009// |
| /typeinfoisderivedfrom63.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom64.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom65.xml/1.4/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom66.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom67.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom68.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom69.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /typeinfoisderivedfrom70.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom71.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /typeinfoisderivedfrom72.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /typeinfoisderivedfrom73.xml/1.2/Fri Apr 3 02:48:00 2009// |
| /userdatahandler01.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /userdatahandler02.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /userdatahandler03.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /userdatahandler04.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /wellformed01.xml/1.2/Fri Apr 3 02:47:59 2009// |
| /wellformed02.xml/1.3/Fri Apr 3 02:48:00 2009// |
| /wellformed03.xml/1.4/Fri Apr 3 02:48:01 2009// |
| /wellformed04.xml/1.3/Fri Apr 3 02:47:59 2009// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/core |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/CVS/Template |
|---|
| --- test/testcases/tests/level3/core/alltests.xml (nonexistent) |
| +++ test/testcases/tests/level3/core/alltests.xml (revision 4364) |
| @@ -0,0 +1,745 @@ |
| +<?xml version="1.0" encoding="UTF-8"?> |
| +<?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| +<!-- |
| +Copyright (c) 2001-2004 World Wide Web Consortium, |
| +(Massachusetts Institute of Technology, Institut National de |
| +Recherche en Informatique et en Automatique, Keio University). All |
| +Rights Reserved. This program is distributed under the W3C's Software |
| +Intellectual Property License. This program is distributed in the |
| +hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| +PURPOSE. |
| +See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| +--> |
| +<!DOCTYPE suite SYSTEM "dom3.dtd"> |
| + |
| +<suite xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="alltests"> |
| +<metadata> |
| +<title>DOM Level 3 Core Test Suite</title> |
| +<creator>DOM Test Suite Project</creator> |
| +</metadata> |
| +<suite.member href="attrgetschematypeinfo01.xml"/> |
| +<suite.member href="attrgetschematypeinfo02.xml"/> |
| +<suite.member href="attrgetschematypeinfo03.xml"/> |
| +<suite.member href="attrgetschematypeinfo04.xml"/> |
| +<suite.member href="attrgetschematypeinfo05.xml"/> |
| +<suite.member href="attrgetschematypeinfo06.xml"/> |
| +<suite.member href="attrgetschematypeinfo07.xml"/> |
| +<suite.member href="attrgetschematypeinfo08.xml"/> |
| +<suite.member href="attrisid01.xml"/> |
| +<suite.member href="attrisid02.xml"/> |
| +<suite.member href="attrisid03.xml"/> |
| +<suite.member href="attrisid04.xml"/> |
| +<suite.member href="attrisid05.xml"/> |
| +<suite.member href="attrisid06.xml"/> |
| +<suite.member href="attrisid07.xml"/> |
| +<suite.member href="canonicalform01.xml"/> |
| +<suite.member href="canonicalform02.xml"/> |
| +<suite.member href="canonicalform03.xml"/> |
| +<suite.member href="canonicalform04.xml"/> |
| +<suite.member href="canonicalform05.xml"/> |
| +<suite.member href="canonicalform06.xml"/> |
| +<suite.member href="canonicalform07.xml"/> |
| +<suite.member href="canonicalform08.xml"/> |
| +<suite.member href="canonicalform09.xml"/> |
| +<suite.member href="canonicalform10.xml"/> |
| +<suite.member href="canonicalform11.xml"/> |
| +<suite.member href="canonicalform12.xml"/> |
| +<suite.member href="cdatasections01.xml"/> |
| +<suite.member href="checkcharacternormalization01.xml"/> |
| +<suite.member href="checkcharacternormalization02.xml"/> |
| +<suite.member href="checkcharacternormalization03.xml"/> |
| +<suite.member href="comments01.xml"/> |
| +<suite.member href="datatypenormalization01.xml"/> |
| +<suite.member href="datatypenormalization02.xml"/> |
| +<suite.member href="datatypenormalization03.xml"/> |
| +<suite.member href="datatypenormalization04.xml"/> |
| +<suite.member href="datatypenormalization05.xml"/> |
| +<suite.member href="datatypenormalization06.xml"/> |
| +<suite.member href="datatypenormalization07.xml"/> |
| +<suite.member href="datatypenormalization08.xml"/> |
| +<suite.member href="datatypenormalization09.xml"/> |
| +<suite.member href="datatypenormalization10.xml"/> |
| +<suite.member href="datatypenormalization11.xml"/> |
| +<suite.member href="datatypenormalization12.xml"/> |
| +<suite.member href="datatypenormalization13.xml"/> |
| +<suite.member href="datatypenormalization14.xml"/> |
| +<suite.member href="datatypenormalization15.xml"/> |
| +<suite.member href="datatypenormalization16.xml"/> |
| +<suite.member href="datatypenormalization17.xml"/> |
| +<suite.member href="datatypenormalization18.xml"/> |
| +<suite.member href="documentadoptnode01.xml"/> |
| +<suite.member href="documentadoptnode02.xml"/> |
| +<suite.member href="documentadoptnode03.xml"/> |
| +<suite.member href="documentadoptnode04.xml"/> |
| +<suite.member href="documentadoptnode05.xml"/> |
| +<suite.member href="documentadoptnode06.xml"/> |
| +<suite.member href="documentadoptnode07.xml"/> |
| +<suite.member href="documentadoptnode08.xml"/> |
| +<suite.member href="documentadoptnode09.xml"/> |
| +<suite.member href="documentadoptnode10.xml"/> |
| +<suite.member href="documentadoptnode11.xml"/> |
| +<suite.member href="documentadoptnode12.xml"/> |
| +<suite.member href="documentadoptnode13.xml"/> |
| +<suite.member href="documentadoptnode14.xml"/> |
| +<suite.member href="documentadoptnode15.xml"/> |
| +<suite.member href="documentadoptnode16.xml"/> |
| +<suite.member href="documentadoptnode17.xml"/> |
| +<suite.member href="documentadoptnode18.xml"/> |
| +<suite.member href="documentadoptnode19.xml"/> |
| +<suite.member href="documentadoptnode20.xml"/> |
| +<suite.member href="documentadoptnode21.xml"/> |
| +<suite.member href="documentadoptnode22.xml"/> |
| +<suite.member href="documentadoptnode23.xml"/> |
| +<suite.member href="documentadoptnode24.xml"/> |
| +<suite.member href="documentadoptnode25.xml"/> |
| +<suite.member href="documentadoptnode26.xml"/> |
| +<suite.member href="documentadoptnode27.xml"/> |
| +<suite.member href="documentadoptnode28.xml"/> |
| +<suite.member href="documentadoptnode30.xml"/> |
| +<suite.member href="documentadoptnode31.xml"/> |
| +<suite.member href="documentadoptnode32.xml"/> |
| +<suite.member href="documentadoptnode33.xml"/> |
| +<suite.member href="documentadoptnode34.xml"/> |
| +<suite.member href="documentadoptnode35.xml"/> |
| +<suite.member href="documentadoptnode36.xml"/> |
| +<suite.member href="documentgetdoctype01.xml"/> |
| +<suite.member href="documentgetdocumenturi01.xml"/> |
| +<suite.member href="documentgetdocumenturi02.xml"/> |
| +<suite.member href="documentgetdocumenturi03.xml"/> |
| +<suite.member href="documentgetinputencoding01.xml"/> |
| +<suite.member href="documentgetinputencoding02.xml"/> |
| +<suite.member href="documentgetinputencoding03.xml"/> |
| +<suite.member href="documentgetinputencoding04.xml"/> |
| +<suite.member href="documentgetstricterrorchecking01.xml"/> |
| +<suite.member href="documentgetstricterrorchecking02.xml"/> |
| +<suite.member href="documentgetxmlencoding01.xml"/> |
| +<suite.member href="documentgetxmlencoding02.xml"/> |
| +<suite.member href="documentgetxmlencoding03.xml"/> |
| +<suite.member href="documentgetxmlencoding04.xml"/> |
| +<suite.member href="documentgetxmlencoding05.xml"/> |
| +<suite.member href="documentgetxmlstandalone01.xml"/> |
| +<suite.member href="documentgetxmlstandalone02.xml"/> |
| +<suite.member href="documentgetxmlstandalone03.xml"/> |
| +<suite.member href="documentgetxmlstandalone04.xml"/> |
| +<suite.member href="documentgetxmlstandalone05.xml"/> |
| +<suite.member href="documentgetxmlversion01.xml"/> |
| +<suite.member href="documentgetxmlversion02.xml"/> |
| +<suite.member href="documentgetxmlversion03.xml"/> |
| +<suite.member href="documentnormalizedocument01.xml"/> |
| +<suite.member href="documentnormalizedocument02.xml"/> |
| +<suite.member href="documentnormalizedocument03.xml"/> |
| +<suite.member href="documentnormalizedocument04.xml"/> |
| +<suite.member href="documentnormalizedocument05.xml"/> |
| +<suite.member href="documentnormalizedocument06.xml"/> |
| +<suite.member href="documentnormalizedocument07.xml"/> |
| +<suite.member href="documentnormalizedocument08.xml"/> |
| +<suite.member href="documentnormalizedocument09.xml"/> |
| +<suite.member href="documentnormalizedocument10.xml"/> |
| +<suite.member href="documentnormalizedocument11.xml"/> |
| +<suite.member href="documentnormalizedocument12.xml"/> |
| +<suite.member href="documentnormalizedocument13.xml"/> |
| +<suite.member href="documentrenamenode01.xml"/> |
| +<suite.member href="documentrenamenode02.xml"/> |
| +<suite.member href="documentrenamenode03.xml"/> |
| +<suite.member href="documentrenamenode04.xml"/> |
| +<suite.member href="documentrenamenode05.xml"/> |
| +<suite.member href="documentrenamenode06.xml"/> |
| +<suite.member href="documentrenamenode07.xml"/> |
| +<suite.member href="documentrenamenode08.xml"/> |
| +<suite.member href="documentrenamenode09.xml"/> |
| +<suite.member href="documentrenamenode10.xml"/> |
| +<suite.member href="documentrenamenode11.xml"/> |
| +<suite.member href="documentrenamenode12.xml"/> |
| +<suite.member href="documentrenamenode13.xml"/> |
| +<suite.member href="documentrenamenode14.xml"/> |
| +<suite.member href="documentrenamenode15.xml"/> |
| +<suite.member href="documentrenamenode16.xml"/> |
| +<suite.member href="documentrenamenode17.xml"/> |
| +<suite.member href="documentrenamenode18.xml"/> |
| +<suite.member href="documentrenamenode19.xml"/> |
| +<suite.member href="documentrenamenode20.xml"/> |
| +<suite.member href="documentrenamenode21.xml"/> |
| +<suite.member href="documentrenamenode22.xml"/> |
| +<suite.member href="documentrenamenode23.xml"/> |
| +<suite.member href="documentrenamenode24.xml"/> |
| +<suite.member href="documentrenamenode25.xml"/> |
| +<suite.member href="documentrenamenode26.xml"/> |
| +<suite.member href="documentrenamenode27.xml"/> |
| +<suite.member href="documentrenamenode28.xml"/> |
| +<suite.member href="documentrenamenode29.xml"/> |
| +<suite.member href="documentsetdocumenturi01.xml"/> |
| +<suite.member href="documentsetdocumenturi02.xml"/> |
| +<suite.member href="documentsetdocumenturi03.xml"/> |
| +<suite.member href="documentsetstricterrorchecking01.xml"/> |
| +<suite.member href="documentsetstricterrorchecking02.xml"/> |
| +<suite.member href="documentsetstricterrorchecking03.xml"/> |
| +<suite.member href="documentsetxmlstandalone01.xml"/> |
| +<suite.member href="documentsetxmlstandalone02.xml"/> |
| +<suite.member href="documentsetxmlversion01.xml"/> |
| +<suite.member href="documentsetxmlversion02.xml"/> |
| +<suite.member href="documentsetxmlversion03.xml"/> |
| +<suite.member href="documentsetxmlversion05.xml"/> |
| +<suite.member href="domconfigcanonicalform1.xml"/> |
| +<suite.member href="domconfigcdatasections1.xml"/> |
| +<suite.member href="domconfigcheckcharacternormalization1.xml"/> |
| +<suite.member href="domconfigcomments1.xml"/> |
| +<suite.member href="domconfigdatatypenormalization1.xml"/> |
| +<suite.member href="domconfigdatatypenormalization2.xml"/> |
| +<suite.member href="domconfigelementcontentwhitespace1.xml"/> |
| +<suite.member href="domconfigentities1.xml"/> |
| +<suite.member href="domconfigerrorhandler1.xml"/> |
| +<suite.member href="domconfigerrorhandler2.xml"/> |
| +<suite.member href="domconfiginfoset1.xml"/> |
| +<suite.member href="domconfignamespacedeclarations1.xml"/> |
| +<suite.member href="domconfignamespaces1.xml"/> |
| +<suite.member href="domconfignamespaces2.xml"/> |
| +<suite.member href="domconfignormalizecharacters1.xml"/> |
| +<suite.member href="domconfigparameternames01.xml"/> |
| +<suite.member href="domconfigschemalocation1.xml"/> |
| +<suite.member href="domconfigschematype1.xml"/> |
| +<suite.member href="domconfigsplitcdatasections1.xml"/> |
| +<suite.member href="domconfigurationcansetparameter01.xml"/> |
| +<suite.member href="domconfigurationcansetparameter02.xml"/> |
| +<suite.member href="domconfigurationcansetparameter03.xml"/> |
| +<suite.member href="domconfigurationcansetparameter04.xml"/> |
| +<suite.member href="domconfigurationcansetparameter06.xml"/> |
| +<suite.member href="domconfigurationgetparameter01.xml"/> |
| +<suite.member href="domconfigurationgetparameter02.xml"/> |
| +<suite.member href="domconfigvalidate1.xml"/> |
| +<suite.member href="domconfigvalidateifschema1.xml"/> |
| +<suite.member href="domconfigwellformed1.xml"/> |
| +<suite.member href="domimplementationgetfeature01.xml"/> |
| +<suite.member href="domimplementationgetfeature02.xml"/> |
| +<suite.member href="domimplementationgetfeature03.xml"/> |
| +<suite.member href="domimplementationgetfeature05.xml"/> |
| +<suite.member href="domimplementationgetfeature06.xml"/> |
| +<suite.member href="domimplementationregistry01.xml"/> |
| +<suite.member href="domimplementationregistry02.xml"/> |
| +<suite.member href="domimplementationregistry03.xml"/> |
| +<suite.member href="domimplementationregistry04.xml"/> |
| +<suite.member href="domimplementationregistry05.xml"/> |
| +<suite.member href="domimplementationregistry06.xml"/> |
| +<suite.member href="domimplementationregistry07.xml"/> |
| +<suite.member href="domimplementationregistry08.xml"/> |
| +<suite.member href="domimplementationregistry09.xml"/> |
| +<suite.member href="domimplementationregistry10.xml"/> |
| +<suite.member href="domimplementationregistry11.xml"/> |
| +<suite.member href="domimplementationregistry12.xml"/> |
| +<suite.member href="domimplementationregistry13.xml"/> |
| +<suite.member href="domimplementationregistry14.xml"/> |
| +<suite.member href="domimplementationregistry15.xml"/> |
| +<suite.member href="domimplementationregistry16.xml"/> |
| +<suite.member href="domimplementationregistry17.xml"/> |
| +<suite.member href="domimplementationregistry18.xml"/> |
| +<suite.member href="domimplementationregistry19.xml"/> |
| +<suite.member href="domimplementationregistry20.xml"/> |
| +<suite.member href="domimplementationregistry21.xml"/> |
| +<suite.member href="domimplementationregistry22.xml"/> |
| +<suite.member href="domimplementationregistry23.xml"/> |
| +<suite.member href="domimplementationregistry24.xml"/> |
| +<suite.member href="domimplementationregistry25.xml"/> |
| +<suite.member href="domstringlistcontains01.xml"/> |
| +<suite.member href="domstringlistcontains02.xml"/> |
| +<suite.member href="domstringlistgetlength01.xml"/> |
| +<suite.member href="domstringlistitem01.xml"/> |
| +<suite.member href="domstringlistitem02.xml"/> |
| +<suite.member href="elementcontentwhitespace01.xml"/> |
| +<suite.member href="elementcontentwhitespace02.xml"/> |
| +<suite.member href="elementcontentwhitespace03.xml"/> |
| +<suite.member href="elementgetschematypeinfo01.xml"/> |
| +<suite.member href="elementgetschematypeinfo02.xml"/> |
| +<suite.member href="elementgetschematypeinfo03.xml"/> |
| +<suite.member href="elementgetschematypeinfo04.xml"/> |
| +<suite.member href="elementgetschematypeinfo05.xml"/> |
| +<suite.member href="elementgetschematypeinfo06.xml"/> |
| +<suite.member href="elementgetschematypeinfo07.xml"/> |
| +<suite.member href="elementsetidattribute01.xml"/> |
| +<suite.member href="elementsetidattribute03.xml"/> |
| +<suite.member href="elementsetidattribute04.xml"/> |
| +<suite.member href="elementsetidattribute05.xml"/> |
| +<suite.member href="elementsetidattribute06.xml"/> |
| +<suite.member href="elementsetidattribute07.xml"/> |
| +<suite.member href="elementsetidattribute08.xml"/> |
| +<suite.member href="elementsetidattribute09.xml"/> |
| +<suite.member href="elementsetidattribute10.xml"/> |
| +<suite.member href="elementsetidattribute11.xml"/> |
| +<suite.member href="elementsetidattributenode01.xml"/> |
| +<suite.member href="elementsetidattributenode02.xml"/> |
| +<suite.member href="elementsetidattributenode03.xml"/> |
| +<suite.member href="elementsetidattributenode04.xml"/> |
| +<suite.member href="elementsetidattributenode05.xml"/> |
| +<suite.member href="elementsetidattributenode06.xml"/> |
| +<suite.member href="elementsetidattributenode07.xml"/> |
| +<suite.member href="elementsetidattributenode08.xml"/> |
| +<suite.member href="elementsetidattributenode09.xml"/> |
| +<suite.member href="elementsetidattributenode10.xml"/> |
| +<suite.member href="elementsetidattributens01.xml"/> |
| +<suite.member href="elementsetidattributens02.xml"/> |
| +<suite.member href="elementsetidattributens03.xml"/> |
| +<suite.member href="elementsetidattributens04.xml"/> |
| +<suite.member href="elementsetidattributens05.xml"/> |
| +<suite.member href="elementsetidattributens06.xml"/> |
| +<suite.member href="elementsetidattributens07.xml"/> |
| +<suite.member href="elementsetidattributens08.xml"/> |
| +<suite.member href="elementsetidattributens09.xml"/> |
| +<suite.member href="elementsetidattributens10.xml"/> |
| +<suite.member href="elementsetidattributens11.xml"/> |
| +<suite.member href="elementsetidattributens12.xml"/> |
| +<suite.member href="elementsetidattributens13.xml"/> |
| +<suite.member href="elementsetidattributens14.xml"/> |
| +<suite.member href="entities01.xml"/> |
| +<suite.member href="entities02.xml"/> |
| +<suite.member href="entities03.xml"/> |
| +<suite.member href="entities04.xml"/> |
| +<suite.member href="entitygetinputencoding01.xml"/> |
| +<suite.member href="entitygetinputencoding02.xml"/> |
| +<suite.member href="entitygetinputencoding03.xml"/> |
| +<suite.member href="entitygetinputencoding04.xml"/> |
| +<suite.member href="entitygetxmlencoding01.xml"/> |
| +<suite.member href="entitygetxmlencoding02.xml"/> |
| +<suite.member href="entitygetxmlencoding03.xml"/> |
| +<suite.member href="entitygetxmlencoding04.xml"/> |
| +<suite.member href="entitygetxmlversion01.xml"/> |
| +<suite.member href="entitygetxmlversion02.xml"/> |
| +<suite.member href="entitygetxmlversion03.xml"/> |
| +<suite.member href="entitygetxmlversion04.xml"/> |
| +<suite.member href="handleerror01.xml"/> |
| +<suite.member href="handleerror02.xml"/> |
| +<suite.member href="hasFeature01.xml"/> |
| +<suite.member href="hasFeature02.xml"/> |
| +<suite.member href="hasFeature03.xml"/> |
| +<suite.member href="hasFeature04.xml"/> |
| +<suite.member href="infoset01.xml"/> |
| +<suite.member href="infoset02.xml"/> |
| +<suite.member href="infoset03.xml"/> |
| +<suite.member href="infoset04.xml"/> |
| +<suite.member href="infoset05.xml"/> |
| +<suite.member href="infoset06.xml"/> |
| +<suite.member href="infoset07.xml"/> |
| +<suite.member href="infoset08.xml"/> |
| +<suite.member href="infoset09.xml"/> |
| +<suite.member href="namespacedeclarations01.xml"/> |
| +<suite.member href="namespacedeclarations02.xml"/> |
| +<suite.member href="nodeappendchild01.xml"/> |
| +<suite.member href="nodeappendchild02.xml"/> |
| +<suite.member href="nodecomparedocumentposition01.xml"/> |
| +<suite.member href="nodecomparedocumentposition02.xml"/> |
| +<suite.member href="nodecomparedocumentposition03.xml"/> |
| +<suite.member href="nodecomparedocumentposition04.xml"/> |
| +<suite.member href="nodecomparedocumentposition05.xml"/> |
| +<suite.member href="nodecomparedocumentposition06.xml"/> |
| +<suite.member href="nodecomparedocumentposition07.xml"/> |
| +<suite.member href="nodecomparedocumentposition08.xml"/> |
| +<suite.member href="nodecomparedocumentposition09.xml"/> |
| +<suite.member href="nodecomparedocumentposition10.xml"/> |
| +<suite.member href="nodecomparedocumentposition11.xml"/> |
| +<suite.member href="nodecomparedocumentposition12.xml"/> |
| +<suite.member href="nodecomparedocumentposition13.xml"/> |
| +<suite.member href="nodecomparedocumentposition14.xml"/> |
| +<suite.member href="nodecomparedocumentposition15.xml"/> |
| +<suite.member href="nodecomparedocumentposition16.xml"/> |
| +<suite.member href="nodecomparedocumentposition17.xml"/> |
| +<suite.member href="nodecomparedocumentposition18.xml"/> |
| +<suite.member href="nodecomparedocumentposition19.xml"/> |
| +<suite.member href="nodecomparedocumentposition20.xml"/> |
| +<suite.member href="nodecomparedocumentposition21.xml"/> |
| +<suite.member href="nodecomparedocumentposition22.xml"/> |
| +<suite.member href="nodecomparedocumentposition23.xml"/> |
| +<suite.member href="nodecomparedocumentposition24.xml"/> |
| +<suite.member href="nodecomparedocumentposition25.xml"/> |
| +<suite.member href="nodecomparedocumentposition26.xml"/> |
| +<suite.member href="nodecomparedocumentposition27.xml"/> |
| +<suite.member href="nodecomparedocumentposition28.xml"/> |
| +<suite.member href="nodecomparedocumentposition29.xml"/> |
| +<suite.member href="nodecomparedocumentposition30.xml"/> |
| +<suite.member href="nodecomparedocumentposition31.xml"/> |
| +<suite.member href="nodecomparedocumentposition32.xml"/> |
| +<suite.member href="nodecomparedocumentposition33.xml"/> |
| +<suite.member href="nodecomparedocumentposition34.xml"/> |
| +<suite.member href="nodecomparedocumentposition35.xml"/> |
| +<suite.member href="nodecomparedocumentposition36.xml"/> |
| +<suite.member href="nodecomparedocumentposition37.xml"/> |
| +<suite.member href="nodecomparedocumentposition38.xml"/> |
| +<suite.member href="nodecomparedocumentposition39.xml"/> |
| +<suite.member href="nodecomparedocumentposition40.xml"/> |
| +<suite.member href="nodegetbaseuri01.xml"/> |
| +<suite.member href="nodegetbaseuri02.xml"/> |
| +<suite.member href="nodegetbaseuri03.xml"/> |
| +<suite.member href="nodegetbaseuri04.xml"/> |
| +<suite.member href="nodegetbaseuri05.xml"/> |
| +<suite.member href="nodegetbaseuri06.xml"/> |
| +<suite.member href="nodegetbaseuri07.xml"/> |
| +<suite.member href="nodegetbaseuri09.xml"/> |
| +<suite.member href="nodegetbaseuri10.xml"/> |
| +<suite.member href="nodegetbaseuri11.xml"/> |
| +<suite.member href="nodegetbaseuri12.xml"/> |
| +<suite.member href="nodegetbaseuri13.xml"/> |
| +<suite.member href="nodegetbaseuri14.xml"/> |
| +<suite.member href="nodegetbaseuri15.xml"/> |
| +<suite.member href="nodegetbaseuri16.xml"/> |
| +<suite.member href="nodegetbaseuri17.xml"/> |
| +<suite.member href="nodegetbaseuri18.xml"/> |
| +<suite.member href="nodegetbaseuri19.xml"/> |
| +<suite.member href="nodegetbaseuri20.xml"/> |
| +<suite.member href="nodegetfeature01.xml"/> |
| +<suite.member href="nodegetfeature02.xml"/> |
| +<suite.member href="nodegetfeature03.xml"/> |
| +<suite.member href="nodegetfeature04.xml"/> |
| +<suite.member href="nodegetfeature05.xml"/> |
| +<suite.member href="nodegetfeature06.xml"/> |
| +<suite.member href="nodegetfeature07.xml"/> |
| +<suite.member href="nodegetfeature08.xml"/> |
| +<suite.member href="nodegetfeature09.xml"/> |
| +<suite.member href="nodegetfeature10.xml"/> |
| +<suite.member href="nodegetfeature11.xml"/> |
| +<suite.member href="nodegetfeature12.xml"/> |
| +<suite.member href="nodegetfeature13.xml"/> |
| +<suite.member href="nodegettextcontent01.xml"/> |
| +<suite.member href="nodegettextcontent02.xml"/> |
| +<suite.member href="nodegettextcontent03.xml"/> |
| +<suite.member href="nodegettextcontent04.xml"/> |
| +<suite.member href="nodegettextcontent05.xml"/> |
| +<suite.member href="nodegettextcontent06.xml"/> |
| +<suite.member href="nodegettextcontent07.xml"/> |
| +<suite.member href="nodegettextcontent08.xml"/> |
| +<suite.member href="nodegettextcontent09.xml"/> |
| +<suite.member href="nodegettextcontent10.xml"/> |
| +<suite.member href="nodegettextcontent11.xml"/> |
| +<suite.member href="nodegettextcontent12.xml"/> |
| +<suite.member href="nodegettextcontent13.xml"/> |
| +<suite.member href="nodegettextcontent14.xml"/> |
| +<suite.member href="nodegettextcontent15.xml"/> |
| +<suite.member href="nodegettextcontent16.xml"/> |
| +<suite.member href="nodegettextcontent17.xml"/> |
| +<suite.member href="nodegettextcontent18.xml"/> |
| +<suite.member href="nodegettextcontent19.xml"/> |
| +<suite.member href="nodegetuserdata01.xml"/> |
| +<suite.member href="nodegetuserdata02.xml"/> |
| +<suite.member href="nodegetuserdata03.xml"/> |
| +<suite.member href="nodegetuserdata04.xml"/> |
| +<suite.member href="nodegetuserdata05.xml"/> |
| +<suite.member href="nodegetuserdata06.xml"/> |
| +<suite.member href="nodegetuserdata07.xml"/> |
| +<suite.member href="nodeinsertbefore01.xml"/> |
| +<suite.member href="nodeinsertbefore02.xml"/> |
| +<suite.member href="nodeinsertbefore03.xml"/> |
| +<suite.member href="nodeinsertbefore04.xml"/> |
| +<suite.member href="nodeinsertbefore05.xml"/> |
| +<suite.member href="nodeinsertbefore06.xml"/> |
| +<suite.member href="nodeinsertbefore07.xml"/> |
| +<suite.member href="nodeinsertbefore08.xml"/> |
| +<suite.member href="nodeinsertbefore09.xml"/> |
| +<suite.member href="nodeinsertbefore10.xml"/> |
| +<suite.member href="nodeinsertbefore11.xml"/> |
| +<suite.member href="nodeinsertbefore12.xml"/> |
| +<suite.member href="nodeinsertbefore13.xml"/> |
| +<suite.member href="nodeinsertbefore14.xml"/> |
| +<suite.member href="nodeinsertbefore15.xml"/> |
| +<suite.member href="nodeinsertbefore16.xml"/> |
| +<suite.member href="nodeinsertbefore17.xml"/> |
| +<suite.member href="nodeinsertbefore18.xml"/> |
| +<suite.member href="nodeinsertbefore19.xml"/> |
| +<suite.member href="nodeinsertbefore20.xml"/> |
| +<suite.member href="nodeinsertbefore21.xml"/> |
| +<suite.member href="nodeinsertbefore22.xml"/> |
| +<suite.member href="nodeinsertbefore23.xml"/> |
| +<suite.member href="nodeinsertbefore24.xml"/> |
| +<suite.member href="nodeinsertbefore25.xml"/> |
| +<suite.member href="nodeisdefaultnamespace01.xml"/> |
| +<suite.member href="nodeisdefaultnamespace02.xml"/> |
| +<suite.member href="nodeisdefaultnamespace03.xml"/> |
| +<suite.member href="nodeisdefaultnamespace04.xml"/> |
| +<suite.member href="nodeisdefaultnamespace05.xml"/> |
| +<suite.member href="nodeisdefaultnamespace06.xml"/> |
| +<suite.member href="nodeisdefaultnamespace07.xml"/> |
| +<suite.member href="nodeisdefaultnamespace08.xml"/> |
| +<suite.member href="nodeisdefaultnamespace09.xml"/> |
| +<suite.member href="nodeisdefaultnamespace10.xml"/> |
| +<suite.member href="nodeisdefaultnamespace11.xml"/> |
| +<suite.member href="nodeisdefaultnamespace13.xml"/> |
| +<suite.member href="nodeisdefaultnamespace14.xml"/> |
| +<suite.member href="nodeisdefaultnamespace15.xml"/> |
| +<suite.member href="nodeisdefaultnamespace16.xml"/> |
| +<suite.member href="nodeisequalnode01.xml"/> |
| +<suite.member href="nodeisequalnode02.xml"/> |
| +<suite.member href="nodeisequalnode03.xml"/> |
| +<suite.member href="nodeisequalnode04.xml"/> |
| +<suite.member href="nodeisequalnode05.xml"/> |
| +<suite.member href="nodeisequalnode06.xml"/> |
| +<suite.member href="nodeisequalnode07.xml"/> |
| +<suite.member href="nodeisequalnode08.xml"/> |
| +<suite.member href="nodeisequalnode09.xml"/> |
| +<suite.member href="nodeisequalnode10.xml"/> |
| +<suite.member href="nodeisequalnode11.xml"/> |
| +<suite.member href="nodeisequalnode12.xml"/> |
| +<suite.member href="nodeisequalnode13.xml"/> |
| +<suite.member href="nodeisequalnode14.xml"/> |
| +<suite.member href="nodeisequalnode15.xml"/> |
| +<suite.member href="nodeisequalnode16.xml"/> |
| +<suite.member href="nodeisequalnode17.xml"/> |
| +<suite.member href="nodeisequalnode18.xml"/> |
| +<suite.member href="nodeisequalnode19.xml"/> |
| +<suite.member href="nodeisequalnode20.xml"/> |
| +<suite.member href="nodeisequalnode21.xml"/> |
| +<suite.member href="nodeisequalnode22.xml"/> |
| +<suite.member href="nodeisequalnode25.xml"/> |
| +<suite.member href="nodeisequalnode26.xml"/> |
| +<suite.member href="nodeisequalnode27.xml"/> |
| +<suite.member href="nodeisequalnode28.xml"/> |
| +<suite.member href="nodeisequalnode29.xml"/> |
| +<suite.member href="nodeisequalnode31.xml"/> |
| +<suite.member href="nodeisequalnode32.xml"/> |
| +<suite.member href="nodeissamenode01.xml"/> |
| +<suite.member href="nodeissamenode02.xml"/> |
| +<suite.member href="nodeissamenode03.xml"/> |
| +<suite.member href="nodeissamenode04.xml"/> |
| +<suite.member href="nodeissamenode05.xml"/> |
| +<suite.member href="nodeissamenode06.xml"/> |
| +<suite.member href="nodeissamenode07.xml"/> |
| +<suite.member href="nodeissamenode08.xml"/> |
| +<suite.member href="nodeissamenode09.xml"/> |
| +<suite.member href="nodeissamenode10.xml"/> |
| +<suite.member href="nodelookupnamespaceuri01.xml"/> |
| +<suite.member href="nodelookupnamespaceuri02.xml"/> |
| +<suite.member href="nodelookupnamespaceuri03.xml"/> |
| +<suite.member href="nodelookupnamespaceuri04.xml"/> |
| +<suite.member href="nodelookupnamespaceuri05.xml"/> |
| +<suite.member href="nodelookupnamespaceuri06.xml"/> |
| +<suite.member href="nodelookupnamespaceuri07.xml"/> |
| +<suite.member href="nodelookupnamespaceuri08.xml"/> |
| +<suite.member href="nodelookupnamespaceuri09.xml"/> |
| +<suite.member href="nodelookupnamespaceuri10.xml"/> |
| +<suite.member href="nodelookupnamespaceuri11.xml"/> |
| +<suite.member href="nodelookupnamespaceuri13.xml"/> |
| +<suite.member href="nodelookupnamespaceuri14.xml"/> |
| +<suite.member href="nodelookupnamespaceuri15.xml"/> |
| +<suite.member href="nodelookupnamespaceuri16.xml"/> |
| +<suite.member href="nodelookupnamespaceuri17.xml"/> |
| +<suite.member href="nodelookupnamespaceuri18.xml"/> |
| +<suite.member href="nodelookupnamespaceuri19.xml"/> |
| +<suite.member href="nodelookupnamespaceuri20.xml"/> |
| +<suite.member href="nodelookupprefix01.xml"/> |
| +<suite.member href="nodelookupprefix02.xml"/> |
| +<suite.member href="nodelookupprefix03.xml"/> |
| +<suite.member href="nodelookupprefix04.xml"/> |
| +<suite.member href="nodelookupprefix05.xml"/> |
| +<suite.member href="nodelookupprefix06.xml"/> |
| +<suite.member href="nodelookupprefix07.xml"/> |
| +<suite.member href="nodelookupprefix08.xml"/> |
| +<suite.member href="nodelookupprefix09.xml"/> |
| +<suite.member href="nodelookupprefix10.xml"/> |
| +<suite.member href="nodelookupprefix11.xml"/> |
| +<suite.member href="nodelookupprefix12.xml"/> |
| +<suite.member href="nodelookupprefix13.xml"/> |
| +<suite.member href="nodelookupprefix14.xml"/> |
| +<suite.member href="nodelookupprefix15.xml"/> |
| +<suite.member href="nodelookupprefix16.xml"/> |
| +<suite.member href="nodelookupprefix17.xml"/> |
| +<suite.member href="nodelookupprefix18.xml"/> |
| +<suite.member href="nodelookupprefix19.xml"/> |
| +<suite.member href="nodelookupprefix20.xml"/> |
| +<suite.member href="noderemovechild01.xml"/> |
| +<suite.member href="noderemovechild02.xml"/> |
| +<suite.member href="noderemovechild03.xml"/> |
| +<suite.member href="noderemovechild04.xml"/> |
| +<suite.member href="noderemovechild05.xml"/> |
| +<suite.member href="noderemovechild07.xml"/> |
| +<suite.member href="noderemovechild08.xml"/> |
| +<suite.member href="noderemovechild09.xml"/> |
| +<suite.member href="noderemovechild10.xml"/> |
| +<suite.member href="noderemovechild11.xml"/> |
| +<suite.member href="noderemovechild12.xml"/> |
| +<suite.member href="noderemovechild13.xml"/> |
| +<suite.member href="noderemovechild14.xml"/> |
| +<suite.member href="noderemovechild15.xml"/> |
| +<suite.member href="noderemovechild16.xml"/> |
| +<suite.member href="noderemovechild17.xml"/> |
| +<suite.member href="noderemovechild18.xml"/> |
| +<suite.member href="noderemovechild19.xml"/> |
| +<suite.member href="noderemovechild20.xml"/> |
| +<suite.member href="noderemovechild21.xml"/> |
| +<suite.member href="noderemovechild22.xml"/> |
| +<suite.member href="noderemovechild23.xml"/> |
| +<suite.member href="noderemovechild24.xml"/> |
| +<suite.member href="noderemovechild25.xml"/> |
| +<suite.member href="noderemovechild26.xml"/> |
| +<suite.member href="noderemovechild27.xml"/> |
| +<suite.member href="noderemovechild28.xml"/> |
| +<suite.member href="noderemovechild29.xml"/> |
| +<suite.member href="noderemovechild30.xml"/> |
| +<suite.member href="noderemovechild31.xml"/> |
| +<suite.member href="nodereplacechild01.xml"/> |
| +<suite.member href="nodereplacechild02.xml"/> |
| +<suite.member href="nodereplacechild03.xml"/> |
| +<suite.member href="nodereplacechild04.xml"/> |
| +<suite.member href="nodereplacechild06.xml"/> |
| +<suite.member href="nodereplacechild07.xml"/> |
| +<suite.member href="nodereplacechild08.xml"/> |
| +<suite.member href="nodereplacechild10.xml"/> |
| +<suite.member href="nodereplacechild12.xml"/> |
| +<suite.member href="nodereplacechild13.xml"/> |
| +<suite.member href="nodereplacechild14.xml"/> |
| +<suite.member href="nodereplacechild15.xml"/> |
| +<suite.member href="nodereplacechild16.xml"/> |
| +<suite.member href="nodereplacechild17.xml"/> |
| +<suite.member href="nodereplacechild18.xml"/> |
| +<suite.member href="nodereplacechild19.xml"/> |
| +<suite.member href="nodereplacechild20.xml"/> |
| +<suite.member href="nodereplacechild21.xml"/> |
| +<suite.member href="nodereplacechild22.xml"/> |
| +<suite.member href="nodereplacechild23.xml"/> |
| +<suite.member href="nodereplacechild24.xml"/> |
| +<suite.member href="nodereplacechild25.xml"/> |
| +<suite.member href="nodereplacechild26.xml"/> |
| +<suite.member href="nodereplacechild27.xml"/> |
| +<suite.member href="nodereplacechild28.xml"/> |
| +<suite.member href="nodereplacechild29.xml"/> |
| +<suite.member href="nodereplacechild30.xml"/> |
| +<suite.member href="nodereplacechild31.xml"/> |
| +<suite.member href="nodereplacechild32.xml"/> |
| +<suite.member href="nodereplacechild33.xml"/> |
| +<suite.member href="nodereplacechild34.xml"/> |
| +<suite.member href="nodereplacechild35.xml"/> |
| +<suite.member href="nodereplacechild36.xml"/> |
| +<suite.member href="nodereplacechild37.xml"/> |
| +<suite.member href="nodereplacechild38.xml"/> |
| +<suite.member href="nodereplacechild39.xml"/> |
| +<suite.member href="nodereplacechild40.xml"/> |
| +<suite.member href="nodesettextcontent01.xml"/> |
| +<suite.member href="nodesettextcontent02.xml"/> |
| +<suite.member href="nodesettextcontent03.xml"/> |
| +<suite.member href="nodesettextcontent04.xml"/> |
| +<suite.member href="nodesettextcontent05.xml"/> |
| +<suite.member href="nodesettextcontent06.xml"/> |
| +<suite.member href="nodesettextcontent07.xml"/> |
| +<suite.member href="nodesettextcontent08.xml"/> |
| +<suite.member href="nodesettextcontent10.xml"/> |
| +<suite.member href="nodesettextcontent11.xml"/> |
| +<suite.member href="nodesettextcontent12.xml"/> |
| +<suite.member href="nodesettextcontent13.xml"/> |
| +<suite.member href="nodesetuserdata01.xml"/> |
| +<suite.member href="nodesetuserdata02.xml"/> |
| +<suite.member href="nodesetuserdata03.xml"/> |
| +<suite.member href="nodesetuserdata04.xml"/> |
| +<suite.member href="nodesetuserdata05.xml"/> |
| +<suite.member href="nodesetuserdata06.xml"/> |
| +<suite.member href="nodesetuserdata07.xml"/> |
| +<suite.member href="nodesetuserdata08.xml"/> |
| +<suite.member href="nodesetuserdata09.xml"/> |
| +<suite.member href="nodesetuserdata10.xml"/> |
| +<suite.member href="normalizecharacters01.xml"/> |
| +<suite.member href="normalizecharacters02.xml"/> |
| +<suite.member href="normalizecharacters03.xml"/> |
| +<suite.member href="normalizecharacters04.xml"/> |
| +<suite.member href="normalizecharacters05.xml"/> |
| +<suite.member href="normalizecharacters06.xml"/> |
| +<suite.member href="normalizecharacters07.xml"/> |
| +<suite.member href="normalizecharacters08.xml"/> |
| +<suite.member href="splitcdatasections01.xml"/> |
| +<suite.member href="textiselementcontentwhitespace01.xml"/> |
| +<suite.member href="textiselementcontentwhitespace02.xml"/> |
| +<suite.member href="textiselementcontentwhitespace03.xml"/> |
| +<suite.member href="textiselementcontentwhitespace04.xml"/> |
| +<suite.member href="textiselementcontentwhitespace05.xml"/> |
| +<suite.member href="textiselementcontentwhitespace06.xml"/> |
| +<suite.member href="textreplacewholetext01.xml"/> |
| +<suite.member href="textreplacewholetext02.xml"/> |
| +<suite.member href="textreplacewholetext03.xml"/> |
| +<suite.member href="textreplacewholetext04.xml"/> |
| +<suite.member href="textreplacewholetext05.xml"/> |
| +<suite.member href="textreplacewholetext06.xml"/> |
| +<suite.member href="textreplacewholetext07.xml"/> |
| +<suite.member href="textreplacewholetext08.xml"/> |
| +<suite.member href="textwholetext01.xml"/> |
| +<suite.member href="textwholetext02.xml"/> |
| +<suite.member href="textwholetext03.xml"/> |
| +<suite.member href="typeinfogettypename03.xml"/> |
| +<suite.member href="typeinfogettypename04.xml"/> |
| +<suite.member href="typeinfogettypenamespace01.xml"/> |
| +<suite.member href="typeinfogettypenamespace03.xml"/> |
| +<suite.member href="typeinfogettypenamespace04.xml"/> |
| +<suite.member href="typeinfoisderivedfrom01.xml"/> |
| +<suite.member href="typeinfoisderivedfrom02.xml"/> |
| +<suite.member href="typeinfoisderivedfrom03.xml"/> |
| +<suite.member href="typeinfoisderivedfrom04.xml"/> |
| +<suite.member href="typeinfoisderivedfrom05.xml"/> |
| +<suite.member href="typeinfoisderivedfrom06.xml"/> |
| +<suite.member href="typeinfoisderivedfrom07.xml"/> |
| +<suite.member href="typeinfoisderivedfrom08.xml"/> |
| +<suite.member href="typeinfoisderivedfrom09.xml"/> |
| +<suite.member href="typeinfoisderivedfrom10.xml"/> |
| +<suite.member href="typeinfoisderivedfrom11.xml"/> |
| +<suite.member href="typeinfoisderivedfrom12.xml"/> |
| +<suite.member href="typeinfoisderivedfrom13.xml"/> |
| +<suite.member href="typeinfoisderivedfrom14.xml"/> |
| +<suite.member href="typeinfoisderivedfrom15.xml"/> |
| +<suite.member href="typeinfoisderivedfrom16.xml"/> |
| +<suite.member href="typeinfoisderivedfrom17.xml"/> |
| +<suite.member href="typeinfoisderivedfrom18.xml"/> |
| +<suite.member href="typeinfoisderivedfrom19.xml"/> |
| +<suite.member href="typeinfoisderivedfrom20.xml"/> |
| +<suite.member href="typeinfoisderivedfrom21.xml"/> |
| +<suite.member href="typeinfoisderivedfrom22.xml"/> |
| +<suite.member href="typeinfoisderivedfrom23.xml"/> |
| +<suite.member href="typeinfoisderivedfrom24.xml"/> |
| +<suite.member href="typeinfoisderivedfrom25.xml"/> |
| +<suite.member href="typeinfoisderivedfrom26.xml"/> |
| +<suite.member href="typeinfoisderivedfrom27.xml"/> |
| +<suite.member href="typeinfoisderivedfrom28.xml"/> |
| +<suite.member href="typeinfoisderivedfrom29.xml"/> |
| +<suite.member href="typeinfoisderivedfrom30.xml"/> |
| +<suite.member href="typeinfoisderivedfrom31.xml"/> |
| +<suite.member href="typeinfoisderivedfrom32.xml"/> |
| +<suite.member href="typeinfoisderivedfrom33.xml"/> |
| +<suite.member href="typeinfoisderivedfrom34.xml"/> |
| +<suite.member href="typeinfoisderivedfrom35.xml"/> |
| +<suite.member href="typeinfoisderivedfrom36.xml"/> |
| +<suite.member href="typeinfoisderivedfrom37.xml"/> |
| +<suite.member href="typeinfoisderivedfrom38.xml"/> |
| +<suite.member href="typeinfoisderivedfrom39.xml"/> |
| +<suite.member href="typeinfoisderivedfrom40.xml"/> |
| +<suite.member href="typeinfoisderivedfrom41.xml"/> |
| +<suite.member href="typeinfoisderivedfrom42.xml"/> |
| +<suite.member href="typeinfoisderivedfrom43.xml"/> |
| +<suite.member href="typeinfoisderivedfrom44.xml"/> |
| +<suite.member href="typeinfoisderivedfrom45.xml"/> |
| +<suite.member href="typeinfoisderivedfrom46.xml"/> |
| +<suite.member href="typeinfoisderivedfrom47.xml"/> |
| +<suite.member href="typeinfoisderivedfrom48.xml"/> |
| +<suite.member href="typeinfoisderivedfrom49.xml"/> |
| +<suite.member href="typeinfoisderivedfrom50.xml"/> |
| +<suite.member href="typeinfoisderivedfrom51.xml"/> |
| +<suite.member href="typeinfoisderivedfrom52.xml"/> |
| +<suite.member href="typeinfoisderivedfrom53.xml"/> |
| +<suite.member href="typeinfoisderivedfrom54.xml"/> |
| +<suite.member href="typeinfoisderivedfrom55.xml"/> |
| +<suite.member href="typeinfoisderivedfrom56.xml"/> |
| +<suite.member href="typeinfoisderivedfrom57.xml"/> |
| +<suite.member href="typeinfoisderivedfrom58.xml"/> |
| +<suite.member href="typeinfoisderivedfrom59.xml"/> |
| +<suite.member href="typeinfoisderivedfrom60.xml"/> |
| +<suite.member href="typeinfoisderivedfrom61.xml"/> |
| +<suite.member href="typeinfoisderivedfrom62.xml"/> |
| +<suite.member href="typeinfoisderivedfrom63.xml"/> |
| +<suite.member href="typeinfoisderivedfrom64.xml"/> |
| +<suite.member href="typeinfoisderivedfrom65.xml"/> |
| +<suite.member href="typeinfoisderivedfrom66.xml"/> |
| +<suite.member href="typeinfoisderivedfrom67.xml"/> |
| +<suite.member href="typeinfoisderivedfrom68.xml"/> |
| +<suite.member href="typeinfoisderivedfrom69.xml"/> |
| +<suite.member href="typeinfoisderivedfrom70.xml"/> |
| +<suite.member href="typeinfoisderivedfrom71.xml"/> |
| +<suite.member href="typeinfoisderivedfrom72.xml"/> |
| +<suite.member href="typeinfoisderivedfrom73.xml"/> |
| +<suite.member href="userdatahandler01.xml"/> |
| +<suite.member href="userdatahandler02.xml"/> |
| +<suite.member href="userdatahandler03.xml"/> |
| +<suite.member href="userdatahandler04.xml"/> |
| +<suite.member href="wellformed01.xml"/> |
| +<suite.member href="wellformed02.xml"/> |
| +<suite.member href="wellformed03.xml"/> |
| +<suite.member href="wellformed04.xml"/> |
| + |
| +</suite> |
| + |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrgetschematypeinfo01.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrgetschematypeinfo01"> |
| <metadata> |
| <title>attrgetschematypeinfo01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call getSchemaTypeInfo on title attribute for the first acronym element. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-schemaTypeInfo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeNamespace"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="typeNS" type="DOMString"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"title"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"CDATA"' ignoreCase="false" id="nameIsCDATA"/> |
| <typeNamespace var="typeNS" obj="typeInfo"/> |
| <assertEquals actual="typeNS" expected='"http://www.w3.org/TR/REC-xml"' ignoreCase="false" id="nsIsXML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrgetschematypeinfo02.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrgetschematypeinfo02"> |
| <metadata> |
| <title>attrgetschematypeinfo02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call getSchemaTypeInfo on id attribute for the third acronym element. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-schemaTypeInfo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeNamespace"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="typeNS" type="DOMString"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"id"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"ID"' ignoreCase="false" id="nameIsID"/> |
| <typeNamespace var="typeNS" obj="typeInfo"/> |
| <assertEquals actual="typeNS" expected='"http://www.w3.org/TR/REC-xml"' ignoreCase="false" id="nsIsXML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrgetschematypeinfo03.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrgetschematypeinfo03"> |
| <metadata> |
| <title>attrgetschematypeinfo03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call getSchemaTypeInfo on title attribute for the first acronym element. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-schemaTypeInfo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeNamespace"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="typeNS" type="DOMString"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"title"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"string"' ignoreCase="false" id="nameIsString"/> |
| <typeNamespace var="typeNS" obj="typeInfo"/> |
| <assertEquals actual="typeNS" expected='"http://www.w3.org/2001/XMLSchema"' ignoreCase="false" id="nsIsXML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrgetschematypeinfo04.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrgetschematypeinfo04"> |
| <metadata> |
| <title>attrgetschematypeinfo04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call getSchemaTypeInfo on id attribute for the third acronym element. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-schemaTypeInfo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeNamespace"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="typeNS" type="DOMString"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"id"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"ID"' ignoreCase="false" id="nameIsID"/> |
| <typeNamespace var="typeNS" obj="typeInfo"/> |
| <assertEquals actual="typeNS" expected='"http://www.w3.org/2001/XMLSchema"' ignoreCase="false" id="nsIsXmlSchema"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrgetschematypeinfo05.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrgetschematypeinfo05"> |
| <metadata> |
| <title>attrgetschematypeinfo05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call getSchemaTypeInfo on class attribute for the third acronym element. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-schemaTypeInfo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeNamespace"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="typeNS" type="DOMString"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"class"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"classType"' ignoreCase="false" id="nameIsClassType"/> |
| <typeNamespace var="typeNS" obj="typeInfo"/> |
| <assertEquals actual="typeNS" expected='"http://www.w3.org/1999/xhtml"' ignoreCase="false" id="nsIsXHTML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrgetschematypeinfo06.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrgetschematypeinfo06"> |
| <metadata> |
| <title>attrgetschematypeinfo06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attr.schemaTypeInfo should return null if not validating or schema validating. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-schemaTypeInfo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeNamespace"/> |
| </metadata> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="typeNS" type="DOMString"/> |
| <load var="doc" href="hc_nodtdstaff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"title"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertNull actual="typeName" id="typeName"/> |
| <typeNamespace var="typeNS" obj="typeInfo"/> |
| <assertNull actual="typeNS" id="typeNS"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrgetschematypeinfo07.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrgetschematypeinfo07"> |
| <metadata> |
| <title>attrgetschematypeinfo07</title> |
| <creator>IBM</creator> |
| <description> |
| The getSchemaTypeInfo method retrieves the type information associated with this attribute. |
| Load a valid document with an XML Schema. |
| Invoke getSchemaTypeInfo method on an attribute having [type definition] property. Expose {name} and {target namespace} |
| properties of the [type definition] property. Verity that the typeName and typeNamespace of the title attribute's |
| schemaTypeInfo are correct. getSchemaTypeInfo on the 'id' attribute of the fourth 'acronym' element |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-schemaTypeInfo"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="typeNamespace" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acElem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acElem" name='"id"'/> |
| <schemaTypeInfo var="attrTypeInfo" obj="attr" interface="Attr"/> |
| <assertNotNull actual="attrTypeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="attrTypeInfo"/> |
| <typeNamespace var="typeNamespace" obj="attrTypeInfo"/> |
| <assertEquals expected='"ID"' actual="typeName" id="attrgetschematypeinfo07_typeName" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/2001/XMLSchema"' actual="typeNamespace" id="attrgetschematypeinfo07_typeNamespace" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrgetschematypeinfo08.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrgetschematypeinfo08"> |
| <metadata> |
| <title>attrgetschematypeinfo08</title> |
| <creator>IBM</creator> |
| <description> |
| The getSchemaTypeInfo method retrieves the type information associated with this attribute. |
| Load a valid document with an XML Schema. |
| Invoke getSchemaTypeInfo method on an attribute having [type definition] property. Expose {name} and {target namespace} |
| properties of the [type definition] property. Verity that the typeName and typeNamespace of the 'title' attribute's (of first 'acronym' element) |
| schemaTypeInfo are correct. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-schemaTypeInfo"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="typeNamespace" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acElem" name='"title"'/> |
| <schemaTypeInfo var="attrTypeInfo" obj="attr" interface="Attr"/> |
| <typeName var="typeName" obj="attrTypeInfo"/> |
| <typeNamespace var="typeNamespace" obj="attrTypeInfo"/> |
| <assertEquals expected='"string"' actual="typeName" id="attrgetschematypeinfo08_typeName" ignoreCase="false"/> |
| <assertEquals actual="typeNamespace" expected='"http://www.w3.org/2001/XMLSchema"' id="attrgetschematypeinfo08_typeNamespace" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrisid01.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrisid01"> |
| <metadata> |
| <title>attrisid01</title> |
| <creator>IBM</creator> |
| <description> |
| Retrieve the third acronyms element's class attribute, whose type is not ID. |
| Invoke isID on the class attribute, this should return false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2003-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-isId"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"class"'/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="AttrIsIDFalse01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrisid02.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrisid02"> |
| <metadata> |
| <title>attrisid02</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttribute on the third acronym element's new attribute and set |
| isID=true. Verify by calling isID on the new attribute and check if the |
| value returned is true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2003-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-isId"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="xmlNS" type="DOMString" value='"http://www.w3.org/XML/1998/namespace"'/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <setAttributeNS obj="acronymElem" namespaceURI='xmlNS' qualifiedName='"xml:lang"' value='"FR-fr"'/> |
| <setIdAttributeNS obj="acronymElem" localName='"lang"' namespaceURI='xmlNS' isId="true"/> |
| <getAttributeNodeNS var="attr" obj="acronymElem" namespaceURI='xmlNS' localName='"lang"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="AttrIsIDTrue02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrisid03.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrisid03"> |
| <metadata> |
| <title>attrisid03</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttribute(false) on a newly created attribute and then check Attr.isID. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2003-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-isId"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="xmlNS" type="DOMString" value='"http://www.w3.org/XML/1998/namespace"'/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <setAttributeNS obj="acronymElem" namespaceURI='xmlNS' qualifiedName='"xml:lang"' value='"FR-fr"'/> |
| <setIdAttributeNS obj="acronymElem" localName='"lang"' namespaceURI='xmlNS' isId="false"/> |
| <getAttributeNodeNS var="attr" obj="acronymElem" namespaceURI='xmlNS' localName='"lang"'/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="AttrIsIDFalse03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrisid04.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrisid04"> |
| <metadata> |
| <title>attrisid04</title> |
| <creator>IBM</creator> |
| <description> |
| Attr.isID should return true for the id attribute on the fourth acronym node |
| since its type is ID. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2003-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-isId"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="clonedacronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"id"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="AttrIsIDTrue04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrisid05.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrisid05"> |
| <metadata> |
| <title>attrisid05</title> |
| <creator>IBM</creator> |
| <description> |
| Retrieve the fourth acronym element's id attribute, whose type is ID. |
| Deep clone the element node and append it as a sibling of the acronym node. |
| We now have two id attributes of type ID with identical values. |
| Invoke isID on the class attribute, should this return true??? |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2003-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-isId"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="clonedacronymElem" type="Element"/> |
| <var name="acronymParentElem" type="Element"/> |
| <var name="appendedNode" type="Node"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="3" interface="NodeList"/> |
| <parentNode var="acronymParentElem" obj="acronymElem" interface="Node"/> |
| <cloneNode var="clonedacronymElem" obj="acronymElem" deep="true"/> |
| <appendChild var="appendedNode" obj="acronymParentElem" newChild="clonedacronymElem"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"id"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="AttrIsIDTrue05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrisid06.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrisid06"> |
| <metadata> |
| <title>attrisid06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke isId on a new Attr node. Check if the value returned is false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2003-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-isId"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="AttrIsIDFalse06"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/attrisid07.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="attrisid07"> |
| <metadata> |
| <title>attrisid07</title> |
| <creator>IBM</creator> |
| <description> |
| The method isId returns whether this attribute is known to be of type ID or not. |
| Add a new attribute of type ID to the third acronym element node of this document. Verify that the method |
| isId returns true. The use of Element.setIdAttributeNS() makes 'isId' a user-determined ID attribute. |
| Import the newly created attribute node into this document. |
| Since user data assocated to the imported node is not carried over, verify that the method isId |
| returns false on the imported attribute node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2003-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Attr-isId"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrImported" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"acronym"' namespaceURI='"*"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <setAttributeNS obj="acronymElem" namespaceURI='"http://www.w3.org/DOM"' qualifiedName='"dom3:newAttr"' value='"null"'/> |
| <setIdAttributeNS obj="acronymElem" localName='"newAttr"' namespaceURI='"http://www.w3.org/DOM"' isId="true"/> |
| <getAttributeNodeNS var="attr" obj="acronymElem" namespaceURI='"http://www.w3.org/DOM"' localName='"newAttr"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="AttrIsIDTrue07_1"/> |
| <importNode var="attrImported" obj="doc" importedNode="attr" deep="false"/> |
| <isId var="id" obj="attrImported"/> |
| <assertFalse actual="id" id="AttrIsID07_isFalseforImportedNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform01.xml |
|---|
| 0,0 → 1,80 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform01"> |
| <metadata> |
| <title>canonicalform01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with 'canonical-form' set to true, check that |
| entity references are expanded and unused entity declaration are maintained. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="ent2" type="Entity"/> |
| <var name="doctype" type="DocumentType"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <!-- add an entity reference to the content of the p element --> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent1"'/> |
| <appendChild var="child" obj="pElem" newChild="entRef"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <lastChild var="child" obj="pElem" interface="Node"/> |
| <assertNotNull actual="child" id="lastChildNotNull"/> |
| <!-- this should be a Text node --> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"#text"' ignoreCase="false" id="firstChildName"/> |
| <nodeValue var="childValue" obj="child"/> |
| <assertEquals actual="childValue" expected='"barfoo"' ignoreCase="false" id="firstChildValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform02.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform02"> |
| <metadata> |
| <title>canonicalform02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with normalize-characters set to false, check that |
| characters are not normalized. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"barsuçon"' |
| ignoreCase="false" id="noCharNormalization"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform03.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform03"> |
| <metadata> |
| <title>canonicalform03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize a document with the 'canonical-form' parameter set to true and |
| check that a CDATASection has been eliminated. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="coalescing" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elemName" type="Element"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="text" type="Text"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elemName" obj="elemList" index="1" interface="NodeList"/> |
| <lastChild var="cdata" obj="elemName" interface="Node"/> |
| <nodeName var="nodeName" obj="cdata"/> |
| <assertEquals actual="nodeName" expected='"#cdata-section"' id="documentnormalizedocument02" ignoreCase="false"/> |
| <domConfig interface="Document" obj="doc" var="domConfig"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalization2Error"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elemName" obj="elemList" index="1" interface="NodeList"/> |
| <lastChild var="text" obj="elemName" interface="Node"/> |
| <nodeName var="nodeName" obj="text"/> |
| <assertEquals actual="nodeName" expected='"#text"' id="documentnormalizedocument02_false" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform04.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform04"> |
| <metadata> |
| <title>canonicalform04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with canonical-form set to true, check that |
| namespace declaration attributes are maintained. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="xmlnsAttr" type="Attr"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getAttributeNode var="xmlnsAttr" obj="docElem" name='"xmlns"'/> |
| <assertNotNull actual="xmlnsAttr" id="xmlnsAttrNotNull"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform05.xml |
|---|
| 0,0 → 1,107 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform05"> |
| <metadata> |
| <title>canonicalform05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add a L1 element to a L2 namespace aware document and perform namespace normalization. Should result |
| in an error. |
| </description> |
| <date qualifier="created">2004-01-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms#normalizeDocumentAlgo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="newChild" type="Element"/> |
| <var name="retval" type="Element"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <var name="problemNode" type="Node"/> |
| <var name="location" type="DOMLocator"/> |
| <var name="lineNumber" type="int"/> |
| <var name="columnNumber" type="int"/> |
| <var name="byteOffset" type="int"/> |
| <var name="utf16Offset" type="int"/> |
| <var name="uri" type="DOMString"/> |
| <var name="type" type="DOMString"/> |
| <var name="message" type="DOMString"/> |
| <var name="relatedException" type="DOMObject"/> |
| <var name="relatedData" type="DOMObject"/> |
| <var name="length" type="int"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <createElement var="newChild" obj="doc" tagName='"br"'/> |
| <appendChild var="retval" obj="elem" newChild="newChild"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <if> |
| <equals actual="severity" expected="2" ignoreCase="false"/> |
| <!-- location should have relatedNode, everything else should be -1 or null --> |
| <location var="location" obj="error"/> |
| <relatedNode var="problemNode" obj="location" interface="DOMLocator"/> |
| <assertSame actual="problemNode" expected="newChild" id="relatedNodeIsL1Node"/> |
| <lineNumber var="lineNumber" obj="location"/> |
| <assertEquals actual="lineNumber" expected="-1" ignoreCase="false" id="lineNumber"/> |
| <columnNumber var="columnNumber" obj="location"/> |
| <assertEquals actual="columnNumber" expected="-1" ignoreCase="false" id="columnNumber"/> |
| <byteOffset var="byteOffset" obj="location"/> |
| <assertEquals actual="byteOffset" expected="-1" ignoreCase="false" id="byteOffset"/> |
| <utf16Offset var="utf16Offset" obj="location"/> |
| <assertEquals actual="utf16Offset" expected="-1" ignoreCase="false" id="utf16Offset"/> |
| <uri var="uri" obj="location" interface="DOMLocator"/> |
| <assertNull actual="uri" id="uri"/> |
| <!-- message and type should be non-empty --> |
| <message var="message" obj="error"/> |
| <length var="length" obj="message" interface="DOMString"/> |
| <assertTrue id="messageNotEmpty"> |
| <greater actual="length" expected="0"/> |
| </assertTrue> |
| <!-- can't make any assertions about type, relatedData and relatedException |
| other than access should not raise exception --> |
| <type var="type" obj="error" interface="DOMError"/> |
| <relatedData var="relatedData" obj="error"/> |
| <relatedException var="relatedException" obj="error"/> |
| <increment var="errorCount" value="1"/> |
| <else> |
| <assertEquals actual="severity" expected="1" ignoreCase="false" id="anyOthersShouldBeWarnings"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneError"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform06.xml |
|---|
| 0,0 → 1,92 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform06"> |
| <metadata> |
| <title>canonicalform06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a document with an XML 1.1 valid but XML 1.0 invalid element and |
| normalize document with canonical-form set to true. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullString" type="DOMString" isNull="true"/> |
| <var name="nullDoctype" type="DocumentType" isNull="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="retval" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="locator" type="DOMLocator"/> |
| <var name="relatedNode" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" |
| namespaceURI="nullString" |
| qualifiedName="nullString" |
| doctype="nullDoctype"/> |
| <assertDOMException id="xml10InvalidName"> |
| <INVALID_CHARACTER_ERR> |
| <createElementNS var="elem" obj="doc" |
| namespaceURI='"http://www.example.org/domts/wellformed01"' |
| qualifiedName='"LegalNameࢎ"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| <try> |
| <xmlVersion obj="doc" value='"1.1"' interface="Document"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <createElementNS var="elem" obj="doc" |
| namespaceURI='"http://www.example.org/domts/wellformed01"' |
| qualifiedName='"LegalNameࢎ"'/> |
| <appendChild var="retval" obj="doc" newChild="elem"/> |
| <xmlVersion obj="doc" value='"1.0"' interface="Document"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <assertEquals actual="severity" expected="2" ignoreCase="false" id="severity"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <assertEquals actual="type" expected='"wf-invalid-character-in-node-name"' |
| ignoreCase="false" id="type"/> |
| <location var="locator" obj="error" interface="DOMError"/> |
| <relatedNode var="relatedNode" obj="locator" interface="DOMLocator"/> |
| <assertSame actual="relatedNode" expected="elem" id="relatedNode"/> |
| </for-each> |
| <assertSize size="1" collection="errors" id="oneError"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform07.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform07"> |
| <metadata> |
| <title>canonicalform07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with canonical-form set to true and validation set to true, check that |
| whitespace in element content is preserved. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="body" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="text" type="Text"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <!-- if we discarded whitespace on parse, add some back --> |
| <if><implementationAttribute name="ignoringElementContentWhitespace" value="true"/> |
| <getElementsByTagName |
| var="bodyList" |
| obj="doc" |
| tagname='"body"' |
| interface="Document"/> |
| <item var="body" obj="bodyList" interface="NodeList" index="0"/> |
| <firstChild var="child" obj="body" interface="Node"/> |
| <createTextNode var="text" obj="doc" data='" "'/> |
| <insertBefore var="child" obj="body" newChild="text" refChild="child"/> |
| </if> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="bodyList" |
| obj="doc" |
| tagname='"body"' |
| interface="Document"/> |
| <item var="body" obj="bodyList" interface="NodeList" index="0"/> |
| <firstChild var="child" obj="body" interface="Node"/> |
| <assertNotNull actual="child" id="firstChildNotNull"/> |
| <!-- this should be a Text node --> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"#text"' ignoreCase="false" id="firstChild"/> |
| <nextSibling var="child" obj="child" interface="Node"/> |
| <assertNotNull actual="child" id="secondChildNotNull"/> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"p"' ignoreCase="false" id="secondChild"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform08.xml |
|---|
| 0,0 → 1,112 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform08"> |
| <metadata> |
| <title>canonicalform08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document based on section 3.1 with canonical-form set to true and check normalized document. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="body" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="length" type="int"/> |
| <var name="text" type="Text"/> |
| <load var="doc" href="canonicalform01" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <firstChild var="node" obj="doc" interface="Node"/> |
| <nodeType var="nodeType" obj="node" interface="Node"/> |
| <assertEquals expected="7" actual="nodeType" ignoreCase="false" id="PIisFirstChild"/> |
| <data var="nodeValue" obj="node" interface="ProcessingInstruction"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="36" ignoreCase="false" id="piDataLength"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisSecondChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="secondChildLength"/> |
| <!-- next sibling is document element --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="1" actual="nodeType" ignoreCase="false" id="ElementisThirdChild"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisFourthChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="fourthChildLength"/> |
| <!-- next sibling is a processing instruction --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="7" actual="nodeType" ignoreCase="false" id="PIisFifthChild"/> |
| <data var="nodeValue" obj="node" interface="ProcessingInstruction"/> |
| <assertEquals actual="nodeValue" expected='""' ignoreCase="false" id="trailingPIData"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisSixthChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="sixthChildLength"/> |
| <!-- next sibling is a comment --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="8" actual="nodeType" ignoreCase="false" id="CommentisSeventhChild"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisEighthChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="eighthChildLength"/> |
| <!-- next sibling is a comment --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="8" actual="nodeType" ignoreCase="false" id="CommentisNinthChild"/> |
| <!-- next sibling is a null --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <assertNull actual="node" id="TenthIsNull"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform09.xml |
|---|
| 0,0 → 1,92 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform09"> |
| <metadata> |
| <title>canonicalform09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document based on section 3.1 with canonical-form set to true |
| and comments to false and check normalized document. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="body" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="length" type="int"/> |
| <var name="text" type="Text"/> |
| <load var="doc" href="canonicalform01" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <setParameter obj="domConfig" name='"comments"' value="false"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <firstChild var="node" obj="doc" interface="Node"/> |
| <nodeType var="nodeType" obj="node" interface="Node"/> |
| <assertEquals expected="7" actual="nodeType" ignoreCase="false" id="PIisFirstChild"/> |
| <data var="nodeValue" obj="node" interface="ProcessingInstruction"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="36" ignoreCase="false" id="piDataLength"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisSecondChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="secondChildLength"/> |
| <!-- next sibling is document element --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="1" actual="nodeType" ignoreCase="false" id="ElementisThirdChild"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisFourthChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="fourthChildLength"/> |
| <!-- next sibling is a processing instruction --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="7" actual="nodeType" ignoreCase="false" id="PIisFifthChild"/> |
| <data var="nodeValue" obj="node" interface="ProcessingInstruction"/> |
| <assertEquals actual="nodeValue" expected='""' ignoreCase="false" id="trailingPIData"/> |
| <!-- next sibling is a null --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <assertNull actual="node" id="SixthIsNull"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform10.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform10"> |
| <metadata> |
| <title>canonicalform10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check elimination of unnecessary namespace prefixes when |
| normalized with canonical-form = true. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="divList" type="NodeList"/> |
| <var name="div" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="node" type="Node"/> |
| <load var="doc" href="canonicalform03" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="divList" obj="doc" |
| tagname='"div"' interface="Document"/> |
| <item var="div" obj="divList" index="5" interface="NodeList"/> |
| <getAttributeNode var="node" obj="div" name='"xmlns"'/> |
| <assertNotNull actual="node" id="xmlnsPresent"/> |
| <getAttributeNode var="node" obj="div" name='"xmlns:a"'/> |
| <assertNull actual="node" id="xmlnsANotPresent"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform11.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform11"> |
| <metadata> |
| <title>canonicalform11</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check that default attributes are made explicitly specified. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="attrSpecified" type="boolean"/> |
| <load var="doc" href="canonicalform03" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="elemList" obj="doc" |
| tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="elem" name='"title"'/> |
| <assertNotNull actual="attr" id="titlePresent"/> |
| <specified var="attrSpecified" obj="attr"/> |
| <assertTrue actual="attrSpecified" id="titleSpecified"/> |
| <nodeValue var="attrValue" obj="attr"/> |
| <assertEquals actual="attrValue" expected='"default"' ignoreCase="false" |
| id="titleValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/canonicalform12.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform12"> |
| <metadata> |
| <title>canonicalform12</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with 'canonical-form' set to true, check that |
| DocumentType nodes are removed. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="doctype" type="DocumentType"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <doctype var="doctype" obj="doc"/> |
| <assertNull actual="doctype" id="docTypeNull"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/cdatasections01.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="cdatasections01"> |
| <metadata> |
| <title>cdatasections01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize a document using Node.normalize and check that |
| the value of the 'cdata-sections' parameter is ignored. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-cdata-sections"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="newCdata" type="CDATASection"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="text" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <createCDATASection var="newCdata" obj="doc" data='"CDATA"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="newCdata"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalize obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalizationError"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <lastChild var="cdata" obj="elem" interface="Node"/> |
| <nodeName var="nodeName" obj="cdata"/> |
| <assertEquals actual="nodeName" expected='"#cdata-section"' id="documentnormalizedocument03_true" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/checkcharacternormalization01.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="checkcharacternormalization01"> |
| <metadata> |
| <title>checkcharacternormalization01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with check-character-normalization set to false, check that |
| no errors are dispatched. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-check-character-normalization"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <setParameter obj="domConfig" name='"check-character-normalization"' value="false"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"barsuçon"' |
| ignoreCase="false" id="noCharNormalization"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/checkcharacternormalization02.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="checkcharacternormalization02"> |
| <metadata> |
| <title>checkcharacternormalization02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with check-character-normalization set to true, check that |
| non-normalized characters are signaled. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-check-character-normalization"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="locator" type="DOMLocator"/> |
| <var name="relatedNode" type="Node"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="errorType" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"check-character-normalization"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"check-character-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <if><equals actual="severity" expected="2" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| <type var="errorType" obj="error" interface="DOMError"/> |
| <!-- type name is specified in LS spec --> |
| <assertEquals actual="errorType" expected='"check-character-normalization-failure"' |
| ignoreCase="false" id="errorType"/> |
| <location var="locator" obj="error"/> |
| <relatedNode var="relatedNode" obj="locator" interface="DOMLocator"/> |
| <assertSame actual="relatedNode" expected="text" id="relatedNodeSame"/> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneError"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/checkcharacternormalization03.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="checkcharacternormalization03"> |
| <metadata> |
| <title>checkcharacternormalization03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document using Node.normalize checking that "check-character-normalization" |
| is ignored. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-check-character-normalization"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"check-character-normalization"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"check-character-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalize obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"barsuçon"' |
| ignoreCase="false" id="noCharNormalization"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/comments01.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="comments01"> |
| <metadata> |
| <title>comments01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check that Node.normalize ignores the setting of configuration parameter 'comments'. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-comments"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="newComment" type="Comment"/> |
| <var name="lastChild" type="Node"/> |
| <var name="text" type="Text"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <createComment var="newComment" obj="doc" data='"COMMENT_NODE"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="newComment"/> |
| <domConfig interface="Document" obj="doc" var="domConfig" /> |
| <setParameter obj="domConfig" name='"comments"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalize obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalizationError"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <lastChild var="lastChild" obj="elem" interface="Node"/> |
| <nodeName var="nodeName" obj="lastChild"/> |
| <assertEquals actual="nodeName" expected='"#comment"' id="documentnormalizedocument04_true" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization01.xml |
|---|
| 0,0 → 1,91 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization01"> |
| <metadata> |
| <title>datatypenormalization01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if double values were normalized. |
| </description> |
| <date qualifier="created">2004-01-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"double"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"+0003.141592600E+0000"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"+0003.141592600E+0000"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"-31415926.00E-7 2.718"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"NaN"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"NaN"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"INF -INF"' ignoreCase="false" id="secondList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"1"' ignoreCase="false" id="thirdValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"1"' ignoreCase="false" id="thirdUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"-0"' ignoreCase="false" id="thirdList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization02.xml |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization02"> |
| <metadata> |
| <title>datatypenormalization02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if decimal values were normalized. |
| </description> |
| <date qualifier="created">2004-01-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"decimal"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"+0003.141592600"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"+0003.141592600"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"+10 .1"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"01"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"01"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"-.001"' ignoreCase="false" id="secondList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization03.xml |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization03"> |
| <metadata> |
| <title>datatypenormalization03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if boolean values were whitespace normalized. |
| </description> |
| <date qualifier="created">2004-01-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"boolean"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"true"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"false"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"false true false"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"1"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"0"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"0 1 0"' ignoreCase="false" id="secondList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization04.xml |
|---|
| 0,0 → 1,90 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization04"> |
| <metadata> |
| <title>datatypenormalization04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if float values were normalized. |
| </description> |
| <date qualifier="created">2004-01-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"float"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"+0003.141592600E+0000"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"+0003.141592600E+0000"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"-31415926.00E-7 2.718"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"NaN"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"NaN"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"INF -INF"' ignoreCase="false" id="secondList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"1"' ignoreCase="false" id="thirdValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"1"' ignoreCase="false" id="thirdUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"-0"' ignoreCase="false" id="thirdList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization05.xml |
|---|
| 0,0 → 1,90 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization05"> |
| <metadata> |
| <title>datatypenormalization05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if dateTime values were correctly normalized. |
| </description> |
| <date qualifier="created">2004-01-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"dateTime"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00-05:00"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"2004-01-21T20:30:00-05:00"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00 2004-01-21T15:30:00Z"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0000-05:00"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0000-05:00"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0000"' ignoreCase="false" id="secondList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0001-05:00"' ignoreCase="false" id="thirdValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0001-05:00"' ignoreCase="false" id="thirdUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0001"' ignoreCase="false" id="thirdList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization06.xml |
|---|
| 0,0 → 1,90 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization06"> |
| <metadata> |
| <title>datatypenormalization06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if time values were normalized. |
| </description> |
| <date qualifier="created">2004-01-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"time"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"15:30:00-05:00"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"15:30:00-05:00"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"15:30:00"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"15:30:00.0000-05:00"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"15:30:00.0000-05:00"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"15:30:00.0000"' ignoreCase="false" id="secondList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"15:30:00.0001-05:00"' ignoreCase="false" id="thirdValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"15:30:00.0001-05:00"' ignoreCase="false" id="thirdUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"15:30:00.0001"' ignoreCase="false" id="thirdList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization07.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization07"> |
| <metadata> |
| <title>datatypenormalization07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The default value for the double element must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"double"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <assertEquals actual="str" expected='"3.1415926E0"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization08.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization08"> |
| <metadata> |
| <title>datatypenormalization08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The default value for the decimal element must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"decimal"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <assertEquals actual="str" expected='"3.1415926"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization09.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization09"> |
| <metadata> |
| <title>datatypenormalization09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The default value for the boolean element must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"boolean"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <assertEquals actual="str" expected='"true"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization10.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization10"> |
| <metadata> |
| <title>datatypenormalization10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The default value for the float element must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"float"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <assertEquals actual="str" expected='"3.1415926E0"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization11.xml |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization11"> |
| <metadata> |
| <title>datatypenormalization11</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The default value for the dateTime element must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"dateTime"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <!-- .0 would not be correct, see http://www.w3.org/2001/05/xmlschema-errata#E2-63 --> |
| <assertEquals actual="str" expected='"2004-01-21T20:30:00Z"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization12.xml |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization12"> |
| <metadata> |
| <title>datatypenormalization12</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Default values must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="datatype_normalization" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"time"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <!-- .0 would not be correct, see http://www.w3.org/2001/05/xmlschema-errata#E2-63 --> |
| <assertEquals actual="str" expected='"20:30:00Z"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization13.xml |
|---|
| 0,0 → 1,78 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization13"> |
| <metadata> |
| <title>datatypenormalization13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if string values were normalized per default whitespace |
| facet of xsd:string. |
| </description> |
| <date qualifier="created">2004-01-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="datatype_normalization2" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"em"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <assertNotNull actual="childNode" id="childNodeNotNull"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='" EMP 0001 "' ignoreCase="false" id="content"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization14.xml |
|---|
| 0,0 → 1,77 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization14"> |
| <metadata> |
| <title>datatypenormalization14</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if string values were normalized per explicit whitespace=preserve. |
| </description> |
| <date qualifier="created">2004-01-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="datatype_normalization2" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"acronym"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <assertNotNull actual="childNode" id="childNodeNotNull"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='" EMP 0001 "' ignoreCase="false" id="content"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization15.xml |
|---|
| 0,0 → 1,84 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization15"> |
| <metadata> |
| <title>datatypenormalization15</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if string values were normalized per an explicit whitespace=collapse. |
| </description> |
| <date qualifier="created">2004-01-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="datatype_normalization2" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"code"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content1"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content2"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content3"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization16.xml |
|---|
| 0,0 → 1,88 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization16"> |
| <metadata> |
| <title>datatypenormalization16</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if string values were normalized per explicit whitespace=replace. |
| </description> |
| <date qualifier="created">2004-01-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="datatype_normalization2" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"sup"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='" EMP 0001 "' ignoreCase="false" id="content1"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content2"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content3"/> |
| <item var="element" obj="elemList" interface="NodeList" index="3"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content4"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization17.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization17"> |
| <metadata> |
| <title>datatypenormalization17</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to false, string values |
| should not be normalized. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="datatype_normalization2" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="false"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"code"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content2"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content3"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertNotEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content1"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/datatypenormalization18.xml |
|---|
| 0,0 → 1,84 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization18"> |
| <metadata> |
| <title>datatypenormalization18</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document using Node.normalize which is not affected by DOMConfiguration unlike |
| Document.normalizeDocument. Strings should not have been normalized. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="canSetDataNorm" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <load var="doc" href="datatype_normalization2" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <canSetParameter var="canSetDataNorm" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| <isTrue value="canSetDataNorm"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalize obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"code"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content2"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content3"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertNotEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content1"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode01.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode01"> |
| <metadata> |
| <title>documentadoptnode01</title> |
| <creator>IBM</creator> |
| <description> |
| Adopt the class attribute node of the fourth acronym element. Check if this attribute has been adopted successfully by verifying the |
| nodeName, nodeType, nodeValue, specified and ownerElement attributes of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attrOwnerElem" type="Element"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="adoptedclass" type="Node"/> |
| <var name="attrsParent" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="firstChild" type="Text"/> |
| <var name="firstChildValue" type="DOMString"/> |
| <var name="secondChild" type="EntityReference"/> |
| <var name="secondChildType" type="int"/> |
| <var name="secondChildName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="element" obj="childList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="element" name='"class"'/> |
| <adoptNode var="adoptedclass" obj="doc" source="attr"/> |
| <if><notNull obj="adoptedclass"/> |
| <nodeName var="nodeName" obj="adoptedclass"/> |
| <nodeValue var="nodeValue" obj="adoptedclass"/> |
| <nodeType var="nodeType" obj="adoptedclass"/> |
| <ownerElement var="attrOwnerElem" obj="adoptedclass" interface="Attr"/> |
| <assertEquals expected='"class"' actual="nodeName" id="documentadoptode01_nodeName" ignoreCase="false"/> |
| <assertEquals expected="2" actual="nodeType" id="documentadoptNode01_nodeType" ignoreCase="false"/> |
| <assertNull actual="attrOwnerElem" id="documentadoptnode01_ownerDoc"/> |
| <!-- The attribute's child list can either be a text node "Yα" or |
| an text node "Y" and a entity reference to "alpha" --> |
| <firstChild var="firstChild" obj="adoptedclass" interface="Node"/> |
| <assertNotNull actual="firstChild" id="firstChildNotNull"/> |
| <nodeValue var="firstChildValue" obj="firstChild"/> |
| <if> |
| <equals actual="firstChildValue" expected='"Y"' ignoreCase="false"/> |
| <nextSibling var="secondChild" obj="firstChild" interface="Node"/> |
| <assertNotNull actual="secondChild" id="secondChildNotNull"/> |
| <nodeType var="secondChildType" obj="secondChild"/> |
| <assertEquals actual="secondChildType" expected="5" |
| id="secondChildIsEntityReference" ignoreCase="false"/> |
| <nodeName var="secondChildName" obj="secondChild"/> |
| <assertEquals actual="secondChildName" expected='"alpha"' |
| id="secondChildIsEnt1Reference" ignoreCase="false"/> |
| <else> |
| <assertEquals expected='"Yα"' actual="nodeValue" id="documentadoptnode01_nodeValue" ignoreCase="false"/> |
| </else> |
| </if> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode02.xml |
|---|
| 0,0 → 1,95 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode02"> |
| <metadata> |
| <title>documentadoptnode02</title> |
| <creator>IBM</creator> |
| <description> |
| Adopt the class attribute node of the fourth acronym element. Check if this attribute has been adopted |
| successfully by verifying the nodeName, nodeType, ownerElement, specified attributes and child nodes |
| of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="attrOwnerElem" type="Element"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="adoptedclass" type="Node"/> |
| <var name="attrsParent" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="isSpecified" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="firstChild" type="Text"/> |
| <var name="firstChildValue" type="DOMString"/> |
| <var name="secondChild" type="EntityReference"/> |
| <var name="secondChildType" type="int"/> |
| <var name="secondChildName" type="DOMString"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="element" obj="childList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="element" name='"class"'/> |
| <adoptNode var="adoptedclass" obj="newDoc" source="attr"/> |
| <if><notNull obj="adoptedclass"/> |
| <nodeName var="nodeName" obj="adoptedclass"/> |
| <nodeValue var="nodeValue" obj="adoptedclass"/> |
| <nodeType var="nodeType" obj="adoptedclass"/> |
| <ownerElement var="attrOwnerElem" obj="adoptedclass" interface="Attr"/> |
| <specified var="isSpecified" obj="adoptedclass" /> |
| <assertEquals expected='"class"' actual="nodeName" id="documentadoptnode02_nodeName" ignoreCase="false"/> |
| <assertEquals expected="2" actual="nodeType" id="documentadoptnode02_nodeType" ignoreCase="false"/> |
| <assertNull actual="attrOwnerElem" id="documentadoptnode02_ownerDoc"/> |
| <assertTrue actual="isSpecified" id="documentadoptnode02_specified"/> |
| <!-- The attribute's child list can either be a text node "Yes" or |
| an text node "Y" and a entity reference to "alpha" --> |
| <firstChild var="firstChild" obj="adoptedclass" interface="Node"/> |
| <assertNotNull actual="firstChild" id="firstChildNotNull"/> |
| <nodeValue var="firstChildValue" obj="firstChild"/> |
| <if> |
| <equals actual="firstChildValue" expected='"Y"' ignoreCase="false"/> |
| <nextSibling var="secondChild" obj="firstChild" interface="Node"/> |
| <assertNotNull actual="secondChild" id="secondChildNotNull"/> |
| <nodeType var="secondChildType" obj="secondChild"/> |
| <assertEquals actual="secondChildType" expected="5" |
| id="secondChildIsEntityReference" ignoreCase="false"/> |
| <nodeName var="secondChildName" obj="secondChild"/> |
| <assertEquals actual="secondChildName" expected='"alpha"' |
| id="secondChildIsEnt1Reference" ignoreCase="false"/> |
| <else> |
| <assertEquals expected='"Yα"' actual="nodeValue" id="documentadoptnode02_nodeValue" ignoreCase="false"/> |
| </else> |
| </if> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode03.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode03"> |
| <metadata> |
| <title>documentadoptnode03</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke adoptNode on this document to adopt the a new namespace aware attribute node. Check |
| if this attribute has been adopted successfully by verifying the nodeName, namespaceURI, prefix, |
| specified and ownerElement attributes of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="adoptedAttr" type="Attr"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeNamespaceURI" type="DOMString"/> |
| <var name="nodePrefix" type="DOMString"/> |
| <var name="attrOwnerElem" type="Element"/> |
| <var name="isSpecified" type="boolean"/> |
| <var name="xmlNS" type="DOMString" value='"http://www.w3.org/XML/1998/namespace"'/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttributeNS var="newAttr" obj="doc" namespaceURI="xmlNS" qualifiedName='"xml:lang"'/> |
| <adoptNode var="adoptedAttr" obj="doc" source="newAttr"/> |
| <if><notNull obj="adoptedAttr"/> |
| <nodeName var="nodeName" obj="adoptedAttr"/> |
| <namespaceURI var="nodeNamespaceURI" obj="adoptedAttr" interface="Node"/> |
| <prefix var="nodePrefix" obj="adoptedAttr"/> |
| <ownerElement var="attrOwnerElem" obj="adoptedAttr" interface="Attr"/> |
| <specified var="isSpecified" obj="adoptedAttr" /> |
| <assertEquals expected='"xml:lang"' actual="nodeName" id="documentadoptode03_nodeName" ignoreCase="false"/> |
| <assertEquals expected='xmlNS' actual="nodeNamespaceURI" id="documentadoptNode03_namespaceURI" ignoreCase="false"/> |
| <assertEquals expected='"xml"' actual="nodePrefix" id="documentadoptnode03_prefix" ignoreCase="false"/> |
| <assertNull actual="attrOwnerElem" id="documentadoptnode03_ownerDoc"/> |
| <assertTrue actual="isSpecified" id="documentadoptnode03_specified"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode04.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode04"> |
| <metadata> |
| <title>documentadoptnode04</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke adoptNode on a new document to adopt a new namespace aware attribute node created by |
| this document. Check if this attribute has been adopted successfully by verifying the nodeName, |
| namespaceURI, prefix, specified and ownerElement attributes of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="adoptedAttr" type="Attr"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeNamespaceURI" type="DOMString"/> |
| <var name="nodePrefix" type="DOMString"/> |
| <var name="attrOwnerElem" type="Element"/> |
| <var name="isSpecified" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="xmlNS" type="DOMString" value='"http://www.w3.org/XML/1998/namespace"'/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createAttributeNS var="newAttr" obj="doc" namespaceURI="xmlNS" qualifiedName='"xml:lang"'/> |
| <adoptNode var="adoptedAttr" obj="newDoc" source="newAttr"/> |
| <if><notNull obj="adoptedAttr"/> |
| <nodeName var="nodeName" obj="adoptedAttr"/> |
| <namespaceURI var="nodeNamespaceURI" obj="adoptedAttr" interface="Node"/> |
| <prefix var="nodePrefix" obj="adoptedAttr"/> |
| <ownerElement var="attrOwnerElem" obj="adoptedAttr" interface="Attr"/> |
| <specified var="isSpecified" obj="adoptedAttr" /> |
| <assertEquals expected='"xml:lang"' actual="nodeName" id="documentadoptnode04_nodeName" ignoreCase="false"/> |
| <assertEquals expected="xmlNS" actual="nodeNamespaceURI" id="documentadoptnode04_namespaceURI" ignoreCase="false"/> |
| <assertEquals expected='"xml"' actual="nodePrefix" id="documentadoptnode04_prefix" ignoreCase="false"/> |
| <assertNull actual="attrOwnerElem" id="documentadoptnode04_ownerDoc"/> |
| <assertTrue actual="isSpecified" id="documentadoptnode04_specified"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode05.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode05"> |
| <metadata> |
| <title>documentadoptnode05</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke adoptNode on a new document to adopt the default attribute "dir". Check if |
| this attribute has been adopted successfully by verifying the nodeName, namespaceURI, prefix, |
| specified and ownerElement attributes of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="elementEmp" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="dir" type="Attr"/> |
| <var name="adoptedAttr" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeNamespaceURI" type="DOMString"/> |
| <var name="nodePrefix" type="DOMString"/> |
| <var name="attrOwnerElem" type="Element"/> |
| <var name="isSpecified" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elementEmp" obj="childList" index="3" interface="NodeList"/> |
| <getAttributeNode var="dir" obj="elementEmp" name='"dir"'/> |
| <adoptNode var="adoptedAttr" obj="newDoc" source="dir"/> |
| <if><notNull obj="adoptedAttr"/> |
| <nodeName var="nodeName" obj="adoptedAttr"/> |
| <namespaceURI var="nodeNamespaceURI" obj="adoptedAttr" interface="Node"/> |
| <prefix var="nodePrefix" obj="adoptedAttr"/> |
| <ownerElement var="attrOwnerElem" obj="adoptedAttr" interface="Attr"/> |
| <specified var="isSpecified" obj="adoptedAttr" /> |
| <assertEquals expected='"dir"' actual="nodeName" id="documentadoptnode05_nodeName" ignoreCase="false"/> |
| <assertNull actual="nodeNamespaceURI" id="documentadoptnode05_namespaceURI"/> |
| <assertNull actual="nodePrefix" id="documentadoptnode05_prefix"/> |
| <assertNull actual="attrOwnerElem" id="documentadoptnode05_ownerDoc"/> |
| <assertTrue actual="isSpecified" id="documentadoptnode05_specified"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode06.xml |
|---|
| 0,0 → 1,87 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode06"> |
| <metadata> |
| <title>documentadoptnode06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke adoptNode on a new document to adopt the a new Attribute node having a Text and an EntityReference |
| child. Check if this attribute has been adopted successfully by verifying the nodeName, namespaceURI, prefix, |
| specified and ownerElement attributes of the adopted node. Also verify the ownerDocument attribute |
| of the adopted node and the adopted children of the attribute node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="newText" type="Text"/> |
| <var name="newEntRef" type="EntityReference"/> |
| <var name="adoptedAttr" type="Attr"/> |
| <var name="adoptText" type="Text"/> |
| <var name="adoptEntRef" type="EntityReference"/> |
| <var name="nodeList" type="NodeList"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeNamespaceURI" type="DOMString"/> |
| <var name="nodePrefix" type="DOMString"/> |
| <var name="attrOwnerElem" type="Element"/> |
| <var name="isSpecified" type="boolean"/> |
| <var name="adoptedTextNodeValue" type="DOMString"/> |
| <var name="adoptedEntRefNodeValue" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="xmlNS" type="DOMString" value='"http://www.w3.org/XML/1998/namespace"'/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createAttributeNS var="newAttr" obj="doc" namespaceURI="xmlNS" qualifiedName='"xml:lang"'/> |
| <createTextNode var="newText" obj="doc" data='"Text Node"'/> |
| <createEntityReference var="newEntRef" obj="doc" name='"alpha"'/> |
| <appendChild obj="newAttr" var="appendedChild" newChild="newText"/> |
| <appendChild obj="newAttr" var="appendedChild" newChild="newEntRef"/> |
| <adoptNode var="adoptedAttr" obj="newDoc" source="newAttr"/> |
| <if><notNull obj="adoptedAttr"/> |
| <nodeName var="nodeName" obj="adoptedAttr"/> |
| <namespaceURI var="nodeNamespaceURI" obj="adoptedAttr" interface="Node"/> |
| <prefix var="nodePrefix" obj="adoptedAttr"/> |
| <ownerElement var="attrOwnerElem" obj="adoptedAttr" interface="Attr"/> |
| <specified var="isSpecified" obj="adoptedAttr" /> |
| <assertEquals expected='"xml:lang"' actual="nodeName" id="documentadoptnode06_nodeName" ignoreCase="false"/> |
| <assertEquals expected="xmlNS" actual="nodeNamespaceURI" id="documentadoptnode06_namespaceURI" ignoreCase="false"/> |
| <assertEquals expected='"xml"' actual="nodePrefix" id="documentadoptnode06_prefix" ignoreCase="false"/> |
| <assertNull actual="attrOwnerElem" id="documentadoptnode06_ownerDoc"/> |
| <assertTrue actual="isSpecified" id="documentadoptnode06_specified"/> |
| <childNodes var="nodeList" obj="adoptedAttr"/> |
| <item var="adoptText" obj="nodeList" index="0" interface="NodeList"/> |
| <item var="adoptEntRef" obj="nodeList" index="1" interface="NodeList"/> |
| <nodeValue var="adoptedTextNodeValue" obj="adoptText"/> |
| <nodeName var="adoptedEntRefNodeValue" obj="adoptEntRef"/> |
| <assertEquals expected='"Text Node"' actual="adoptedTextNodeValue" id="documentadoptnode06_TextNodeValue" ignoreCase="false"/> |
| <assertEquals expected='"alpha"' actual="adoptedEntRefNodeValue" id="documentadoptnode06_EntRefNodeValue" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode07.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode07"> |
| <metadata> |
| <title>documentadoptnode07</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document with the value of the source parameter as itself. |
| Verify if a NOT_SUPPORTED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="adoptedDoc" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <adoptNode var="adoptedDoc" obj="doc" source="doc"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode08.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode08"> |
| <metadata> |
| <title>documentadoptnode08</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document with a new document as the value of the |
| source parameter. Verify if a NOT_SUPPORTED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="adoptedDoc" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <adoptNode var="adoptedDoc" obj="doc" source="newDoc"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode09.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode09"> |
| <metadata> |
| <title>documentadoptnode09</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on a new document with this document as the value of the |
| source parameter. Verify if a NOT_SUPPORTED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="adoptedDoc" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <adoptNode var="adoptedDoc" obj="newDoc" source="doc"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode10.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode10"> |
| <metadata> |
| <title>documentadoptnode10</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document with the value of the source parameter as this |
| documents doctype node. Verify if a NOT_SUPPORTED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="adoptedDocType" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <adoptNode var="adoptedDocType" obj="doc" source="docType"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode11.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode11"> |
| <metadata> |
| <title>documentadoptnode11</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document with the value of the source parameter equal to a new |
| doctype node. Verify if a NOT_SUPPORTED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="adoptedDocType" type="Node"/> |
| <var name="nullPubID" type="DOMString" isNull="true"/> |
| <var name="nullSysID" type="DOMString" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="docType" obj="domImpl" qualifiedName="rootName" publicId="nullPubID" systemId="nullSysID"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <adoptNode var="adoptedDocType" obj="doc" source="docType"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode12.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode12"> |
| <metadata> |
| <title>documentadoptnode12</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on a new document with the value of the source parameter equal to a new |
| doctype node. Verify if a NOT_SUPPORTED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="adoptedDocType" type="Node"/> |
| <var name="nullPubID" type="DOMString" isNull="true"/> |
| <var name="nullSysID" type="DOMString" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="docType" obj="domImpl" qualifiedName="rootName" publicId="nullPubID" systemId="nullSysID"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="docType"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <adoptNode var="adoptedDocType" obj="newDoc" source="docType"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode13.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode13"> |
| <metadata> |
| <title>documentadoptnode13</title> |
| <creator>IBM</creator> |
| <description> |
| Using the method adoptNode, adopt a newly created DocumentFragment node populated with |
| with the first acronym element of this Document. Since the decendants of a documentFragment |
| are recursively adopted, check if the adopted node has children. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="childList" type="NodeList"/> |
| <var name="success" type="boolean"/> |
| <var name="acronymNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="adoptedDocFrag" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFragment" obj="doc"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymNode" obj="childList" index="0" interface="NodeList"/> |
| <appendChild obj="docFragment" var="appendedChild" newChild="acronymNode"/> |
| <adoptNode var="adoptedDocFrag" obj="doc" source="docFragment"/> |
| <if><notNull obj="adoptedDocFrag"/> |
| <hasChildNodes var="success" obj="adoptedDocFrag"/> |
| <assertTrue actual="success" id="documentadoptnode13"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode14.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode14"> |
| <metadata> |
| <title>documentadoptnode14</title> |
| <creator>IBM</creator> |
| <description> |
| Using the method adoptNode in a new Document, adopt a newly created DocumentFragment node populated with |
| with the first acronym element of this Document as its newChild. Since the decendants of a documentFragment |
| are recursively adopted, check if the adopted node has children. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="childList" type="NodeList"/> |
| <var name="success" type="boolean"/> |
| <var name="acronymNode" type="Node"/> |
| <var name="adoptedDocFrag" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="imported" type="Node"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createDocumentFragment var="docFragment" obj="newDoc"/> |
| <importNode obj="newDoc" var="imported" importedNode="docElem" deep="true"/> |
| <documentElement var="docElem" obj="newDoc"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="imported"/> |
| <getElementsByTagName var="childList" obj="newDoc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymNode" obj="childList" index="0" interface="NodeList"/> |
| <appendChild obj="docFragment" var="appendedChild" newChild="acronymNode"/> |
| <adoptNode var="adoptedDocFrag" obj="newDoc" source="docFragment"/> |
| <if><notNull obj="adoptedDocFrag"/> |
| <hasChildNodes var="success" obj="adoptedDocFrag"/> |
| <assertTrue actual="success" id="documentadoptnode14"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode15.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode15"> |
| <metadata> |
| <title>documentadoptnode15</title> |
| <creator>IBM</creator> |
| <description> |
| Using the method adoptNode, adopt a newly created DocumentFragment node without any children. |
| Check if the adopted node has no children. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="success" type="boolean"/> |
| <var name="adoptedDocFrag" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFragment" obj="doc"/> |
| <adoptNode var="adoptedDocFrag" obj="doc" source="docFragment"/> |
| <if><notNull obj="adoptedDocFrag"/> |
| <hasChildNodes var="success" obj="adoptedDocFrag"/> |
| <assertFalse actual="success" id="documentadoptnode15"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode16.xml |
|---|
| 0,0 → 1,88 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode16"> |
| <metadata> |
| <title>documentadoptnode16</title> |
| <creator>IBM</creator> |
| <description> |
| Create a document fragment with an entity reference, adopt the node and check |
| that the entity reference value comes from the adopting documents DTD. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFragment" type="DocumentFragment"/> |
| <var name="childList" type="NodeList"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="Element"/> |
| <var name="childsAttr" type="Attr"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="textNode" type="Text"/> |
| <var name="adopted" type="Node"/> |
| <var name="parentImp" type="Element"/> |
| <var name="childImp" type="Element"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="childAttrImp" type="Attr"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="attrNode" type="Attr"/> |
| <var name="firstChild" type="Node"/> |
| <var name="firstChildType" type="int"/> |
| <var name="firstChildName" type="DOMString"/> |
| <var name="firstChildValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFragment" obj="doc"/> |
| <createElement var="parent" obj="doc" tagName='"parent"'/> |
| <createElement var="child" obj="doc" tagName='"child"'/> |
| <createAttribute var="childsAttr" obj="doc" name='"state"'/> |
| <createEntityReference var="entRef" obj="doc" name='"gamma"'/> |
| <createTextNode var="textNode" obj="doc" data='"Test"'/> |
| <appendChild obj="childsAttr" var="appendedChild" newChild="entRef"/> |
| <setAttributeNode obj="child" var="attrNode" newAttr="childsAttr"/> |
| <appendChild obj="child" var="appendedChild" newChild="textNode"/> |
| <appendChild obj="parent" var="appendedChild" newChild="child"/> |
| <appendChild obj="docFragment" var="appendedChild" newChild="parent"/> |
| <adoptNode var="adopted" obj="doc" source="docFragment"/> |
| <if><notNull obj="adopted"/> |
| <firstChild var="parentImp" obj="adopted" interface="Node"/> |
| <firstChild var="childImp" obj="parentImp" interface="Node"/> |
| <attributes var="attributes" obj="childImp"/> |
| <getNamedItem var="childAttrImp" obj="attributes" name='"state"'/> |
| <firstChild var="firstChild" obj="childAttrImp" interface="Node"/> |
| <assertNotNull actual="firstChild" id="firstChildNotNull"/> |
| <nodeName var="firstChildName" obj="firstChild"/> |
| <nodeValue var="firstChildValue" obj="firstChild"/> |
| <nodeType var="firstChildType" obj="firstChild"/> |
| <if> |
| <!-- if first child of the attribute is an |
| entity, then it should be for ent3 --> |
| <equals actual="firstChildType" expected="5"/> |
| <assertEquals actual="firstChildName" expected='"gamma"' |
| ignoreCase="false" id="firstChildEnt3Ref"/> |
| <else> |
| <!-- otherwise the value should be expanded as Texas --> |
| <assertEquals expected='"Texas"' actual="firstChildValue" |
| id="documentadoptnode16" |
| ignoreCase="false"/> |
| </else> |
| </if> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode17.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode17"> |
| <metadata> |
| <title>documentadoptnode17</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document with the entity ent1 as the source. Since this is |
| read-only verify if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entityMap" type="NamedNodeMap"/> |
| <var name="ent" type="Entity"/> |
| <var name="adoptedEnt" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entityMap" obj="docType"/> |
| <getNamedItem var="ent" obj="entityMap" name='"alpha"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <adoptNode var="adoptedEnt" obj="doc" source="ent"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode18.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode18"> |
| <metadata> |
| <title>documentadoptnode18</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on a new document with the entity ent4 as the source. Since this is |
| read-only verify if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entityMap" type="NamedNodeMap"/> |
| <var name="ent" type="Entity"/> |
| <var name="adoptedEnt" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entityMap" obj="docType"/> |
| <getNamedItem var="ent" obj="entityMap" name='"delta"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <adoptNode var="adoptedEnt" obj="newDoc" source="ent"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode19.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode19"> |
| <metadata> |
| <title>documentadoptnode19</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document with the notation notation1 as the source. Since this is |
| read-only verify if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notationMap" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="adoptedNotaion" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notationMap" obj="docType"/> |
| <getNamedItem var="notation" obj="notationMap" name='"notation1"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <adoptNode var="adoptedNotaion" obj="doc" source="notation"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode20.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode20"> |
| <metadata> |
| <title>documentadoptnode20</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on a new document with the notation notation2 as the source. Since this is |
| read-only verify if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notationMap" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="adoptedNotation" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notationMap" obj="docType"/> |
| <getNamedItem var="notation" obj="notationMap" name='"notation2"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <adoptNode var="adoptedNotation" obj="newDoc" source="notation"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode21.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode21"> |
| <metadata> |
| <title>documentadoptnode21</title> |
| <creator>IBM</creator> |
| <description> |
| The adoptNode method changes the ownerDocument of a node, its children, as well as the |
| attached attribute nodes if there are any. If the node has a parent it is first removed |
| from its parent child list. |
| Invoke the adoptNode method on this Document with the source node being an existing attribute |
| that is a part of this Document. Verify that the returned adopted node's nodeName, nodeValue |
| and nodeType are as expected and that the ownerElement attribute of the returned attribute node |
| was set to null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="attrOwnerElem" type="Element"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="adoptedTitle" type="Node"/> |
| <var name="attrsParent" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="element" obj="childList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="element" name='"title"'/> |
| <adoptNode var="adoptedTitle" obj="doc" source="attr"/> |
| <nodeName var="nodeName" obj="adoptedTitle"/> |
| <nodeValue var="nodeValue" obj="adoptedTitle"/> |
| <nodeType var="nodeType" obj="adoptedTitle"/> |
| <ownerElement var="attrOwnerElem" obj="adoptedTitle" interface="Attr"/> |
| <assertEquals expected='"title"' actual="nodeName" id="documentadoptnode21_nodeName" ignoreCase="false"/> |
| <assertEquals expected="2" actual="nodeType" id="documentadoptnode21_nodeType" ignoreCase="false"/> |
| <assertEquals expected='"Yes"' actual="nodeValue" id="documentadoptnode21_nodeValue" ignoreCase="false"/> |
| <assertNull actual="attrOwnerElem" id="documentadoptnode21_ownerDoc"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode22.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode22"> |
| <metadata> |
| <title>documentadoptnode22</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document with the documentElement as the source. |
| Verify if the node has been adopted correctly by its nodeName. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElement" type="Element"/> |
| <var name="adoptedNode" type="Node"/> |
| <var name="success" type="boolean"/> |
| <var name="nodeNameOrig" type="DOMString"/> |
| <var name="nodeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElement" obj="doc"/> |
| <adoptNode var="adoptedNode" obj="doc" source="docElement"/> |
| <if><notNull obj="adoptedNode"/> |
| <hasChildNodes var="success" obj="adoptedNode"/> |
| <assertTrue actual="success" id="documentadoptnode22_1"/> |
| <nodeName var="nodeName" obj="adoptedNode"/> |
| <nodeName var="nodeNameOrig" obj="docElement"/> |
| <assertEquals actual="nodeNameOrig" expected="nodeName" id="documentadoptnode22_2" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode23.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode23"> |
| <metadata> |
| <title>documentadoptnode23</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document with the first acronym element node of this |
| Document as the source. Verify if the node has been adopted correctly by checking the |
| length of the this elements childNode list before and after. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="adoptedNode" type="Node"/> |
| <var name="acronymElem" type="Node"/> |
| <var name="acronymElemLen" type="int"/> |
| <var name="adoptedLen" type="int"/> |
| <var name="acronymElemChild" type="NodeList"/> |
| <var name="adoptedNodeChild" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="childList" index="0" interface="NodeList"/> |
| <adoptNode var="adoptedNode" obj="doc" source="acronymElem"/> |
| <if><notNull obj="adoptedNode"/> |
| <childNodes var="acronymElemChild" obj="acronymElem"/> |
| <length var="acronymElemLen" obj="acronymElemChild" interface="NodeList"/> |
| <childNodes var="adoptedNodeChild" obj="adoptedNode"/> |
| <length var="adoptedLen" obj="adoptedNodeChild" interface="NodeList"/> |
| <assertEquals actual="acronymElemLen" expected="adoptedLen" id="documentadoptnode23" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode24.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode24"> |
| <metadata> |
| <title>documentadoptnode24</title> |
| <creator>IBM</creator> |
| <description> |
| The adoptNode method changes the ownerDocument of a node, its children, as well as the |
| attached attribute nodes if there are any. If the node has a parent it is first removed |
| from its parent child list. |
| For Element Nodes, specified attribute nodes of the source element are adopted, Default |
| attributes are discarded and descendants of the source element are recursively adopted. |
| Invoke the adoptNode method on a new document with the first code element node of this |
| Document as the source. Verify if the node has been adopted correctly by checking the |
| length of the this elements childNode list before and after. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="childList" type="NodeList"/> |
| <var name="adoptedNode" type="Node"/> |
| <var name="codeElem" type="Element"/> |
| <var name="codeElemChildren" type="NodeList"/> |
| <var name="adoptedChildren" type="NodeList"/> |
| <var name="codeElemLen" type="int"/> |
| <var name="adoptedLen" type="int"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom:test"' doctype="nullDocType"/> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI='"*"' localName='"code"' interface="Document"/> |
| <item var="codeElem" obj="childList" index="0" interface="NodeList"/> |
| <adoptNode var="adoptedNode" obj="newDoc" source="codeElem"/> |
| <childNodes var="codeElemChildren" obj="codeElem"/> |
| <childNodes var="adoptedChildren" obj="adoptedNode"/> |
| <length var="codeElemLen" obj="codeElemChildren" interface="NodeList"/> |
| <length var="adoptedLen" obj="adoptedChildren" interface="NodeList"/> |
| <assertEquals actual="codeElemLen" expected="adoptedLen" id="documentadoptnode24" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode25.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode25"> |
| <metadata> |
| <title>documentadoptnode25</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on a new document with a new Element of this |
| Document as the source. Verify if the node has been adopted correctly by checking the |
| nodeName of the adopted Element. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newElem" type="Element"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="adoptedNode" type="Node"/> |
| <var name="adoptedName" type="DOMString"/> |
| <var name="adoptedNS" type="DOMString"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <createElementNS var="newElem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"th"'/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='rootNS' qualifiedName='rootName' doctype="nullDocType"/> |
| <adoptNode var="adoptedNode" obj="newDoc" source="newElem"/> |
| <if><notNull obj="adoptedNode"/> |
| <nodeName var="adoptedName" obj="adoptedNode"/> |
| <namespaceURI var="adoptedNS" obj="adoptedNode" interface="Node"/> |
| <assertEquals actual="adoptedName" expected='"th"' id="documentadoptnode25_1" ignoreCase="false"/> |
| <assertEquals actual="adoptedNS" expected='"http://www.w3.org/1999/xhtml"' id="documentadoptnode25_2" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode26.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode26"> |
| <metadata> |
| <title>documentadoptnode26</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document using a new Element and a new attribute created in |
| a new Document as the source. Verify if the node has been adopted correctly by checking the |
| nodeName of the adopted Element and by checking if the attribute was adopted. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="adoptedNode" type="Node"/> |
| <var name="adoptedName" type="DOMString"/> |
| <var name="adoptedNS" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootTagname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootTagname" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='rootNS' qualifiedName='rootTagname' doctype="nullDocType"/> |
| <createElementNS var="newElem" obj="newDoc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"head"'/> |
| <setAttributeNS obj="newElem" |
| namespaceURI='"http://www.w3.org/XML/1998/namespace"' |
| qualifiedName='"xml:lang"' value='"en-US"'/> |
| <documentElement obj="newDoc" var="docElem"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="newElem"/> |
| <adoptNode var="adoptedNode" obj="doc" source="newElem"/> |
| <if><notNull obj="adoptedNode"/> |
| <nodeName var="adoptedName" obj="adoptedNode"/> |
| <namespaceURI var="adoptedNS" obj="adoptedNode" interface="Node"/> |
| <assertEquals actual="adoptedName" expected='"head"' id="documentadoptnode26_1" ignoreCase="false"/> |
| <assertEquals actual="adoptedNS" expected='"http://www.w3.org/1999/xhtml"' id="documentadoptnode26_2" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode27.xml |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode27"> |
| <metadata> |
| <title>documentadoptnode27</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document using a new imported Element and a new attribute created in |
| a new Document as the source. Verify if the node has been adopted correctly by checking the |
| nodeName of the adopted Element and by checking if the attribute was adopted. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="newImpElem" type="Element"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="adoptedNode" type="Node"/> |
| <var name="adoptedName" type="DOMString"/> |
| <var name="adoptedNS" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootTagname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootTagname" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='rootNS' qualifiedName='rootTagname' doctype="nullDocType"/> |
| <createElementNS var="newElem" obj="newDoc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:head"'/> |
| <setAttributeNS obj="newElem" |
| namespaceURI='"http://www.w3.org/XML/1998/namespace"' |
| qualifiedName='"xml:lang"' value='"en-US"'/> |
| <documentElement obj="newDoc" var="docElem"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="newElem"/> |
| <importNode var="newImpElem" obj="doc" importedNode="newElem" deep="true"/> |
| <adoptNode var="adoptedNode" obj="doc" source="newImpElem"/> |
| <if><notNull obj="adoptedNode"/> |
| <nodeName var="adoptedName" obj="adoptedNode"/> |
| <namespaceURI var="adoptedNS" obj="adoptedNode" interface="Node"/> |
| <assertEquals actual="adoptedName" expected='"xhtml:head"' id="documentadoptnode27_1" ignoreCase="false"/> |
| <assertEquals actual="adoptedNS" expected='"http://www.w3.org/1999/xhtml"' id="documentadoptnode27_2" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode28.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode28"> |
| <metadata> |
| <title>documentadoptnode28</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document using the "p" element with the default |
| Attribute "dir" as the source. Verify if the node has been adopted correctly by |
| checking the nodeName of the adopted Element and by checking if the attribute was adopted. |
| Note the default attribute should be adopted in this case. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="adoptedNode" type="Node"/> |
| <var name="employeeElem" type="Node"/> |
| <var name="attrImp" type="Attr"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="employeeElem" obj="childList" index="3" interface="NodeList"/> |
| <adoptNode var="adoptedNode" obj="doc" source="employeeElem"/> |
| <if><notNull obj="adoptedNode"/> |
| <getAttributeNode var="attrImp" obj="adoptedNode" name='"dir"'/> |
| <nodeName var="nodeName" obj="attrImp"/> |
| <assertEquals actual="nodeName" expected='"dir"' id="documentadoptnode28" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode30.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode30"> |
| <metadata> |
| <title>documentadoptnode30</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document using a new Text node as the source. Verify |
| if the node has been adopted correctly by checking the nodeValue of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newText" type="Text"/> |
| <var name="adoptedText" type="Text"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createTextNode var="newText" obj="doc" data='"Document.adoptNode test for a TEXT_NODE"'/> |
| <adoptNode var="adoptedText" obj="doc" source="newText"/> |
| <if><notNull obj="adoptedText"/> |
| <nodeValue var="nodeValue" obj="adoptedText"/> |
| <assertEquals actual="nodeValue" expected='"Document.adoptNode test for a TEXT_NODE"' id="documentadoptnode30" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode31.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode31"> |
| <metadata> |
| <title>documentadoptnode31</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document using a new Text node from a new Document as the |
| source. Verify if the node has been adopted correctly by checking the nodeValue of the adopted |
| node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="newText" type="Text"/> |
| <var name="adoptedText" type="Text"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createTextNode var="newText" obj="newDoc" data='"new Document.adoptNode test for a TEXT_NODE"'/> |
| <adoptNode var="adoptedText" obj="doc" source="newText"/> |
| <if><notNull obj="adoptedText"/> |
| <nodeValue var="nodeValue" obj="adoptedText"/> |
| <assertEquals actual="nodeValue" expected='"new Document.adoptNode test for a TEXT_NODE"' id="documentadoptnode31" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode32.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode32"> |
| <metadata> |
| <title>documentadoptnode32</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on another document using a new CDataSection node created in this |
| Document as the source. Verify if the node has been adopted correctly by checking the nodeValue |
| of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docAdopter" type="Document"/> |
| <var name="newCDATA" type="Node"/> |
| <var name="adoptedCDATA" type="Node"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <load var="docAdopter" href="hc_staff" willBeModified="true"/> |
| <createCDATASection var="newCDATA" obj="doc" data='"Document.adoptNode test for a CDATASECTION_NODE"'/> |
| <adoptNode var="adoptedCDATA" obj="docAdopter" source="newCDATA"/> |
| <if><notNull obj="adoptedCDATA"/> |
| <nodeValue var="nodeValue" obj="adoptedCDATA"/> |
| <assertEquals actual="nodeValue" expected='"Document.adoptNode test for a CDATASECTION_NODE"' id="documentadoptnode32" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode33.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode33"> |
| <metadata> |
| <title>documentadoptnode33</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document using a new CDataSection node created in a new |
| Document as the source. Verify if the node has been adopted correctly by checking the nodeValue |
| of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="newCDATA" type="Node"/> |
| <var name="adoptedCDATA" type="Node"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createCDATASection var="newCDATA" obj="newDoc" data='"Document.adoptNode test for a CDATASECTION_NODE"'/> |
| <adoptNode var="adoptedCDATA" obj="doc" source="newCDATA"/> |
| <if><notNull obj="adoptedCDATA"/> |
| <nodeValue var="nodeValue" obj="adoptedCDATA"/> |
| <assertEquals actual="nodeValue" expected='"Document.adoptNode test for a CDATASECTION_NODE"' id="documentadoptnode33" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode34.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode34"> |
| <metadata> |
| <title>documentadoptnode34</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on a new document using a new Comment node created in it |
| as the source. Verify if the node has been adopted correctly by checking the nodeValue |
| of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="newComment" type="Node"/> |
| <var name="adoptedComment" type="Node"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createComment var="newComment" obj="newDoc" data='"Document.adoptNode test for a COMMENT_NODE"'/> |
| <adoptNode var="adoptedComment" obj="newDoc" source="newComment"/> |
| <if><notNull obj="adoptedComment"/> |
| <nodeValue var="nodeValue" obj="adoptedComment"/> |
| <assertEquals actual="nodeValue" expected='"Document.adoptNode test for a COMMENT_NODE"' id="documentadoptnode34" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode35.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode35"> |
| <metadata> |
| <title>documentadoptnode35</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document using a new PI node created in a new doc |
| as the source. Verify if the node has been adopted correctly by checking the nodeValue |
| of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="newPI" type="ProcessingInstruction"/> |
| <var name="adoptedPI" type="ProcessingInstruction"/> |
| <var name="piTarget" type="DOMString"/> |
| <var name="piData" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createProcessingInstruction var="newPI" obj="newDoc" target='"PITarget"' data='"PIData"'/> |
| <adoptNode var="adoptedPI" obj="doc" source="newPI"/> |
| <if><notNull obj="adoptedPI"/> |
| <target var="piTarget" obj="adoptedPI" interface="ProcessingInstruction"/> |
| <data var="piData" obj="adoptedPI" interface="ProcessingInstruction"/> |
| <assertEquals actual="piTarget" expected='"PITarget"' id="documentadoptnode35_Target" ignoreCase="false"/> |
| <assertEquals actual="piData" expected='"PIData"' id="documentadoptnode35_Data" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentadoptnode36.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentadoptnode36"> |
| <metadata> |
| <title>documentadoptnode36</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the adoptNode method on this document using a new PI node created in a new doc |
| as the source. Verify if the node has been adopted correctly by checking the nodeValue |
| of the adopted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-adoptNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="newPI1" type="ProcessingInstruction"/> |
| <var name="newPI2" type="ProcessingInstruction"/> |
| <var name="adoptedPI1" type="ProcessingInstruction"/> |
| <var name="adoptedPI2" type="ProcessingInstruction"/> |
| <var name="piTarget" type="DOMString"/> |
| <var name="piData" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createProcessingInstruction var="newPI1" obj="newDoc" target='"PITarget"' data='"PIData"'/> |
| <createProcessingInstruction var="newPI2" obj="doc" target='"PITarget"' data='"PIData"'/> |
| <adoptNode var="adoptedPI1" obj="newDoc" source="newPI1"/> |
| <if><notNull obj="adoptedPI1"/> |
| <adoptNode var="adoptedPI2" obj="newDoc" source="newPI2"/> |
| <if><notNull obj="adoptedPI2"/> |
| <target var="piTarget" obj="adoptedPI1" interface="ProcessingInstruction"/> |
| <data var="piData" obj="adoptedPI1" interface="ProcessingInstruction"/> |
| <assertEquals actual="piTarget" expected='"PITarget"' id="documentadoptnode36_Target1" ignoreCase="false"/> |
| <assertEquals actual="piData" expected='"PIData"' id="documentadoptnode36_Data1" ignoreCase="false"/> |
| <target var="piTarget" obj="adoptedPI2" interface="ProcessingInstruction"/> |
| <data var="piData" obj="adoptedPI2" interface="ProcessingInstruction"/> |
| <assertEquals actual="piTarget" expected='"PITarget"' id="documentadoptnode36_Target2" ignoreCase="false"/> |
| <assertEquals actual="piData" expected='"PIData"' id="documentadoptnode36_Data2" ignoreCase="false"/> |
| </if> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetdoctype01.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetdoctype01"> |
| <metadata> |
| <title>documentgetdoctype01</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive the doctype node, create a new Doctype node, call replaceChild and try replacing the |
| docType node with a new docType node. Check if the docType node was correctly replaced with |
| the new one. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-B63ED1A31"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="newDocType" type="DocumentType"/> |
| <var name="replacedDocType" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newSysID" type="DOMString"/> |
| <var name="nullPubID" type="DOMString" isNull="true"/> |
| <var name="nullSysID" type="DOMString" isNull="true"/> |
| <var name="replaced" type="Node"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <name var="rootName" obj="docType" interface="DocumentType"/> |
| <implementation obj="doc" var="domImpl"/> |
| <createDocumentType obj="domImpl" var="newDocType" qualifiedName="rootName" publicId="nullPubID" systemId="nullSysID"/> |
| <try> |
| <replaceChild obj="doc" var="replaced" newChild="newDocType" oldChild="docType"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <doctype var="replacedDocType" obj="doc"/> |
| <systemId var="newSysID" obj="replacedDocType" interface="DocumentType"/> |
| <assertNull actual="newSysID" id="newSysIdNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetdocumenturi01.xml |
|---|
| 0,0 → 1,35 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetdocumenturi01"> |
| <metadata> |
| <title>documentgetdocumenturi01</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive the documentURI of this document, and verify if it is not null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-documentURI"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentURI var="docURI" obj="doc" /> |
| <assertNotNull actual="docURI" id="documentgetdocumenturi01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetdocumenturi02.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetdocumenturi02"> |
| <metadata> |
| <title>documentgetdocumenturi02</title> |
| <creator>IBM</creator> |
| <description> |
| Create a new Document, retreive its documentURI, and verify if it is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-documentURI"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docURI" type="DOMString"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <documentURI var="docURI" obj="newDoc" /> |
| <assertNull actual="docURI" id="documentgetdocumenturi02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetdocumenturi03.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetdocumenturi03"> |
| <metadata> |
| <title>documentgetdocumenturi03</title> |
| <creator>IBM</creator> |
| <description> |
| Import the documentElement node of this document into a new document. Since this node is |
| now owned by the importing document, its documentURI attribute value should be null |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-documentURI"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="importedOwner" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemImported" type="Node"/> |
| <var name="docURI" type="DOMString"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <importNode var="docElemImported" obj="newDoc" importedNode="docElem" deep="false" /> |
| <ownerDocument var="importedOwner" obj="docElemImported"/> |
| <documentURI var="docURI" obj="importedOwner" /> |
| <assertNull actual="docURI" id="documentgetdocumenturi03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetinputencoding01.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetinputencoding01"> |
| <metadata> |
| <title>documentgetinputencoding01</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getInputEncoding method on a UTF-8 encoded document and check if the |
| value returned is UTF-8. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-inputEncoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <inputEncoding obj="doc" var="encodingName" interface="Document"/> |
| <assertEquals expected='"UTF-8"' actual="encodingName" id="documentgetinputencoding01" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetinputencoding02.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetinputencoding02"> |
| <metadata> |
| <title>documentgetinputencoding02</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getInputEncoding method on a new document and check if the value returned |
| is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-inputEncoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="encodingName" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <inputEncoding obj="newDoc" var="encodingName" interface="Document"/> |
| <assertNull actual="encodingName" id="documentgetinputencoding02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetinputencoding03.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetinputencoding03"> |
| <metadata> |
| <title>documentgetinputencoding03</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getInputEncoding method on a on a UTF-16 (BE) encoded document and check if the value returned |
| is UTF-16BE. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-inputEncoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="barfoo_utf16" willBeModified="false"/> |
| <inputEncoding obj="doc" var="encodingName" interface="Document"/> |
| <assertEquals expected='"UTF-16BE"' actual="encodingName" id="documentgetinputencoding03" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetinputencoding04.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetinputencoding04"> |
| <metadata> |
| <title>documentgetinputencoding04</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getInputEncoding method on a cloned UTF-8 encoded document |
| and check if the value returned is UTF-8 or null (implementation dependent). |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-inputEncoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="cloned" type="Document"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="barfoo_utf8" willBeModified="false"/> |
| <cloneNode var="cloned" obj="doc" deep="true"/> |
| <inputEncoding obj="cloned" var="encodingName" interface="Document"/> |
| <assertTrue id="documentgetinputencoding04"> |
| <or> |
| <equals expected='"UTF-8"' actual="encodingName" ignoreCase="true"/> |
| <isNull obj="encodingName" /> |
| </or> |
| </assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetstricterrorchecking01.xml |
|---|
| 0,0 → 1,35 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetstricterrorchecking01"> |
| <metadata> |
| <title>documentgetstricterrorchecking01</title> |
| <creator>IBM</creator> |
| <description> |
| Verify if the (default) value of the strictErrorChecking attribute of this document object is true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-strictErrorChecking"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="strictErrorCheckingValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <strictErrorChecking var="strictErrorCheckingValue" obj="doc" /> |
| <assertTrue actual="strictErrorCheckingValue" id="documentgetstricterrorchecking01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetstricterrorchecking02.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetstricterrorchecking02"> |
| <metadata> |
| <title>documentgetstricterrorchecking02</title> |
| <creator>IBM</creator> |
| <description> |
| Verify if the (default)value of the strictErrorChecking attribute of a new Document object is true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-strictErrorChecking"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="strictErrorCheckingValue" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <strictErrorChecking var="strictErrorCheckingValue" obj="newDoc" /> |
| <assertTrue actual="strictErrorCheckingValue" id="documentgetstricterrorchecking02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlencoding01.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlencoding01"> |
| <metadata> |
| <title>documentgetxmlencoding01</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getXmlEncoding method on a UTF-8 encoded XML document in which the encoding pseudo |
| attribute in its XMLDecl is UTF-8 and check if the value returned is UTF-8. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-encoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="barfoo_utf8" willBeModified="false"/> |
| <xmlEncoding obj="doc" var="encodingName" interface="Document"/> |
| <assertEquals expected='"uTf-8"' actual="encodingName" id="documentgetxmlencoding01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlencoding02.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlencoding02"> |
| <metadata> |
| <title>documentgetxmlencoding02</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getXmlEncoding method on a new document and check if the value returned |
| is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-encoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="encodingName" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <xmlEncoding obj="newDoc" var="encodingName" interface="Document"/> |
| <assertNull actual="encodingName" id="documentgetxmlencoding02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlencoding03.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlencoding03"> |
| <metadata> |
| <title>documentgetxmlencoding03</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getXmlEncoding method on a UTF-16 encoded document and check if the value returned |
| is UTF-16. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-encoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="barfoo_utf16" willBeModified="false"/> |
| <xmlEncoding obj="doc" var="encodingName" interface="Document"/> |
| <assertEquals expected='"uTf-16"' actual="encodingName" id="documentgetxmlencoding03" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlencoding04.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlencoding04"> |
| <metadata> |
| <title>documentgetxmlencoding04</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getXmlEncoding method on a UTF-8 encoded XML document that does not contain |
| the encoding pseudo attribute in its XMLDecl and check if the value returend is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-encoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <xmlEncoding obj="doc" var="encodingName" interface="Document"/> |
| <assertNull actual="encodingName" id="documentgetxmlencoding04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlencoding05.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlencoding05"> |
| <metadata> |
| <title>documentgetxmlencoding05</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getXmlEncoding method on a cloned UTF-8 encoded document |
| and check if the value returned is UTF-8 or null (implementation dependent). |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-encoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="cloned" type="Document"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="barfoo_utf8" willBeModified="false"/> |
| <cloneNode var="cloned" obj="doc" deep="true"/> |
| <xmlEncoding obj="cloned" var="encodingName" interface="Document"/> |
| <assertTrue id="documentgetxmlencoding05"> |
| <or> |
| <equals expected='"uTf-8"' actual="encodingName" ignoreCase="false"/> |
| <isNull obj="encodingName" /> |
| </or> |
| </assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlstandalone01.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlstandalone01"> |
| <metadata> |
| <title>documentgetxmlstandalone01</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive the xmlStandalone attribute of a document for which standalone was not specified, this |
| should return false since the default for standalone is no when external markup decls |
| are present. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-standalone"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="standalone" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <xmlStandalone var="standalone" obj="doc" /> |
| <assertFalse actual="standalone" id="documentgetxmlstandalone01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlstandalone02.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlstandalone02"> |
| <metadata> |
| <title>documentgetxmlstandalone02</title> |
| <creator>IBM</creator> |
| <description> |
| The value of the standalone pesudo-attribute for a new Document should be false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-standalone"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="standalone" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <xmlStandalone var="standalone" obj="newDoc" /> |
| <assertFalse actual="standalone" id="documentgetxmlstandalone02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlstandalone03.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlstandalone03"> |
| <metadata> |
| <title>documentgetxmlstandalone03</title> |
| <creator>IBM</creator> |
| <description> |
| The value of the standalone attribute for an XML document with the standalone="no" |
| should be false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-standalone"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="standalone" type="boolean"/> |
| <load var="doc" href="barfoo_standalone_no" willBeModified="false"/> |
| <xmlStandalone var="standalone" obj="doc" /> |
| <assertFalse actual="standalone" id="documentgetxmlstandalone03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlstandalone04.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlstandalone04"> |
| <metadata> |
| <title>documentgetxmlstandalone04</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive the documentURI of a document for which standalone was specified as "yes", this |
| should return true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-standalone"/> |
| </metadata> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="standalone" type="boolean"/> |
| <load var="doc" href="barfoo_standalone_yes" willBeModified="false"/> |
| <xmlStandalone var="standalone" obj="doc" /> |
| <assertTrue actual="standalone" id="documentgetxmlstandalone04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlstandalone05.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlstandalone05"> |
| <metadata> |
| <title>documentgetxmlstandalone05</title> |
| <creator>IBM</creator> |
| <description> |
| Cretae a new DocumentType node whose systemId is StaffNS.DTD. Create a new Document |
| node. Check if the value of the standalone attribute on the new Document is false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-standalone"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="newDocType" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="standalone" type="boolean"/> |
| <var name="nullPubId" type="DOMString" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="sysId" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <doctype var="docType" obj="doc"/> |
| <systemId var="sysId" obj="docType" interface="DocumentType"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="newDocType" obj="domImpl" qualifiedName="rootName" publicId="nullPubId" systemId="sysId"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="newDocType"/> |
| <xmlStandalone var="standalone" obj="newDoc" /> |
| <assertFalse actual="standalone" id="documentgetxmlstandalone05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlversion01.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlversion01"> |
| <metadata> |
| <title>documentgetxmlversion01</title> |
| <creator>IBM</creator> |
| <description> |
| Check if the value of the version attribute in the XML declaration of this document |
| obtained by parsing staffNS.xml is "1.0". |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-version"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="versionValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <xmlVersion var="versionValue" obj="doc" interface="Document"/> |
| <assertEquals actual="versionValue" expected='"1.0"' id="documentgetxmlversion01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlversion02.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlversion02"> |
| <metadata> |
| <title>documentgetxmlversion02</title> |
| <creator>IBM</creator> |
| <description> |
| Check if the value of the version attribute in the XML declaration of a new document |
| is "1.0". |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-version"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="versionValue" type="DOMString"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <xmlVersion var="versionValue" obj="newDoc" interface="Document"/> |
| <assertEquals actual="versionValue" expected='"1.0"' id="documentgetxmlversion02" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentgetxmlversion03.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentgetxmlversion03"> |
| <metadata> |
| <title>documentgetxmlversion03</title> |
| <creator>IBM</creator> |
| <description> |
| Check if the value of the version attribute in a XML document without a XMLDecl is |
| is "1.0". |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-version"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="versionValue" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <xmlVersion var="versionValue" obj="doc" interface="Document"/> |
| <assertEquals actual="versionValue" expected='"1.0"' id="documentgetxmlversion03" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument01.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument01"> |
| <metadata> |
| <title>documentnormalizedocument01</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the normalizeDocument method on this document. Retreive the documentElement node |
| and check the nodeName of this node to make sure it has not changed. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemNodeName" type="DOMString"/> |
| <var name="origDocElemNodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <nodeName var="origDocElemNodeName" obj="docElem"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <documentElement var="docElem" obj="doc"/> |
| <nodeName var="docElemNodeName" obj="docElem"/> |
| <assertEquals actual="docElemNodeName" expected='origDocElemNodeName' id="documentnormalizedocument01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument02.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument02"> |
| <metadata> |
| <title>documentnormalizedocument02</title> |
| <creator>IBM</creator> |
| <description> |
| Normalize a document with the 'cdata-sections' parameter set to false and |
| check if the CDATASection has been preserved. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-cdata-sections"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="coalescing" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elemName" type="Element"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="text" type="Text"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elemName" obj="elemList" index="1" interface="NodeList"/> |
| <lastChild var="cdata" obj="elemName" interface="Node"/> |
| <nodeName var="nodeName" obj="cdata"/> |
| <assertEquals actual="nodeName" expected='"#cdata-section"' id="documentnormalizedocument02" ignoreCase="false"/> |
| <domConfig interface="Document" obj="doc" var="domConfig"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalizationError"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elemName" obj="elemList" index="1" interface="NodeList"/> |
| <lastChild var="cdata" obj="elemName" interface="Node"/> |
| <nodeName var="nodeName" obj="cdata"/> |
| <assertEquals actual="nodeName" expected='"#cdata-section"' id="documentnormalizedocument02_true" ignoreCase="false"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="false"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalization2Error"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elemName" obj="elemList" index="1" interface="NodeList"/> |
| <lastChild var="text" obj="elemName" interface="Node"/> |
| <nodeName var="nodeName" obj="text"/> |
| <assertEquals actual="nodeName" expected='"#text"' id="documentnormalizedocument02_false" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument03.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument03"> |
| <metadata> |
| <title>documentnormalizedocument03</title> |
| <creator>IBM</creator> |
| <description> |
| Normalize a document with a created CDATA section with the |
| 'cdata-sections' parameter set to true then to false and check if |
| the CDATASection has been preserved and then coalesced. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=416"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-cdata-sections"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="newCdata" type="CDATASection"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="text" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <createCDATASection var="newCdata" obj="doc" data='"CDATA"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="newCdata"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalizationError"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <lastChild var="cdata" obj="elem" interface="Node"/> |
| <nodeName var="nodeName" obj="cdata"/> |
| <assertEquals actual="nodeName" expected='"#cdata-section"' id="documentnormalizedocument03_true" ignoreCase="false"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="false"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalization2Error"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <lastChild var="text" obj="elem" interface="Node"/> |
| <nodeName var="nodeName" obj="text"/> |
| <assertEquals actual="nodeName" expected='"#text"' id="documentnormalizedocument03_false" ignoreCase="false"/> |
| <nodeValue var="nodeValue" obj="text"/> |
| <assertEquals actual="nodeValue" expected='"barCDATA"' id="normalizedValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument04.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument04"> |
| <metadata> |
| <title>documentnormalizedocument04</title> |
| <creator>IBM</creator> |
| <description> |
| Append a Comment node and normalize with "comments" set to false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=416"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-comments"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="newComment" type="Comment"/> |
| <var name="lastChild" type="Node"/> |
| <var name="text" type="Text"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <createComment var="newComment" obj="doc" data='"COMMENT_NODE"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="newComment"/> |
| <domConfig interface="Document" obj="doc" var="domConfig" /> |
| <setParameter obj="domConfig" name='"comments"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalizationError"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <lastChild var="lastChild" obj="elem" interface="Node"/> |
| <nodeName var="nodeName" obj="lastChild"/> |
| <assertEquals actual="nodeName" expected='"#comment"' id="documentnormalizedocument04_true" ignoreCase="false"/> |
| <setParameter obj="domConfig" name='"comments"' value="false"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalization2Error"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <lastChild var="lastChild" obj="elem" interface="Node"/> |
| <nodeName var="nodeName" obj="lastChild"/> |
| <assertEquals actual="nodeName" expected='"#text"' id="hasChildText" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument05.xml |
|---|
| 0,0 → 1,103 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument05"> |
| <metadata> |
| <title>documentnormalizedocument05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add a L1 element to a L2 namespace aware document and perform namespace normalization. Should result |
| in an error. |
| </description> |
| <date qualifier="created">2004-01-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms#normalizeDocumentAlgo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespaces"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="newChild" type="Element"/> |
| <var name="retval" type="Element"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <var name="problemNode" type="Node"/> |
| <var name="location" type="DOMLocator"/> |
| <var name="lineNumber" type="int"/> |
| <var name="columnNumber" type="int"/> |
| <var name="byteOffset" type="int"/> |
| <var name="utf16Offset" type="int"/> |
| <var name="uri" type="DOMString"/> |
| <var name="type" type="DOMString"/> |
| <var name="message" type="DOMString"/> |
| <var name="relatedException" type="DOMObject"/> |
| <var name="relatedData" type="DOMObject"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <createElement var="newChild" obj="doc" tagName='"br"'/> |
| <appendChild var="retval" obj="elem" newChild="newChild"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"namespaces"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <if> |
| <equals actual="severity" expected="2" ignoreCase="false"/> |
| <!-- location should have relatedNode, everything else should be -1 or null --> |
| <location var="location" obj="error"/> |
| <relatedNode var="problemNode" obj="location" interface="DOMLocator"/> |
| <assertSame actual="problemNode" expected="newChild" id="relatedNodeIsL1Node"/> |
| <lineNumber var="lineNumber" obj="location"/> |
| <assertEquals actual="lineNumber" expected="-1" ignoreCase="false" id="lineNumber"/> |
| <columnNumber var="columnNumber" obj="location"/> |
| <assertEquals actual="columnNumber" expected="-1" ignoreCase="false" id="columnNumber"/> |
| <byteOffset var="byteOffset" obj="location"/> |
| <assertEquals actual="byteOffset" expected="-1" ignoreCase="false" id="byteOffset"/> |
| <utf16Offset var="utf16Offset" obj="location"/> |
| <assertEquals actual="utf16Offset" expected="-1" ignoreCase="false" id="utf16Offset"/> |
| <uri var="uri" obj="location" interface="DOMLocator"/> |
| <assertNull actual="uri" id="uri"/> |
| <!-- message and type should be non-empty --> |
| <message var="message" obj="error"/> |
| <length var="length" obj="message" interface="DOMString"/> |
| <assertTrue id="messageNotEmpty"> |
| <greater actual="length" expected="0"/> |
| </assertTrue> |
| <!-- can't make any assertions about type, relatedData and relatedException |
| other than access should not raise exception --> |
| <type var="type" obj="error" interface="DOMError"/> |
| <relatedData var="relatedData" obj="error"/> |
| <relatedException var="relatedException" obj="error"/> |
| <increment var="errorCount" value="1"/> |
| <else> |
| <assertEquals actual="severity" expected="1" ignoreCase="false" id="anyOthersShouldBeWarnings"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument06.xml |
|---|
| 0,0 → 1,136 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument06"> |
| <metadata> |
| <title>documentnormalizedocument06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add a CDATASection containing "]]>" perform normalization with split-cdata-sections=true. Should result |
| in an warning. |
| </description> |
| <date qualifier="created">2004-01-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-split-cdata-sections"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-severity"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-message"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-relatedException"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-relatedData"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-location"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-line-number"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-column-number"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-byteOffset"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-utf16Offset"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-node"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-uri"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=542"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="newChild" type="CDATASection"/> |
| <var name="oldChild" type="Node"/> |
| <var name="retval" type="Node"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="splittedCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <var name="problemNode" type="Node"/> |
| <var name="location" type="DOMLocator"/> |
| <var name="lineNumber" type="int"/> |
| <var name="columnNumber" type="int"/> |
| <var name="byteOffset" type="int"/> |
| <var name="utf16Offset" type="int"/> |
| <var name="uri" type="DOMString"/> |
| <var name="type" type="DOMString"/> |
| <var name="message" type="DOMString"/> |
| <var name="relatedException" type="DOMObject"/> |
| <var name="relatedData" type="DOMObject"/> |
| <var name="length" type="int"/> |
| <var name="nodeType" type="int"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <createCDATASection var="newChild" obj="doc" data='"this is not ]]> good"'/> |
| <firstChild var="oldChild" obj="elem" interface="Node"/> |
| <replaceChild var="retval" obj="elem" newChild="newChild" oldChild="oldChild"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"split-cdata-sections"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <firstChild var="newChild" obj="elem" interface="Node"/> |
| <!-- the first child should not be a CDATASection containing a ]]> --> |
| <nodeValue var="nodeValue" obj="newChild"/> |
| <nodeType var="nodeType" obj="newChild"/> |
| <assertFalse id="wasSplit"> |
| <and> |
| <equals actual="nodeType" expected="4" ignoreCase="false"/> |
| <contains obj="nodeValue" str='"]]>"' interface="DOMString"/> |
| </and> |
| </assertFalse> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <type var="type" obj="error" interface="DOMError"/> |
| <severity var="severity" obj="error"/> |
| <if> |
| <equals actual="type" expected='"cdata-sections-splitted"' ignoreCase="false"/> |
| <!-- related data is first split node --> |
| <relatedData var="relatedData" obj="error"/> |
| <assertSame actual="relatedData" expected="newChild" id="relatedData"/> |
| <!-- severity is warning --> |
| <assertEquals actual="severity" expected="1" ignoreCase="false" id="severity"/> |
| <!-- message should be non-empty --> |
| <message var="message" obj="error"/> |
| <length var="length" obj="message" interface="DOMString"/> |
| <assertTrue id="messageNotEmpty"> |
| <greater actual="length" expected="0"/> |
| </assertTrue> |
| <!-- can't make any assertions about relatedException |
| other than access should not raise exception --> |
| <relatedException var="relatedException" obj="error"/> |
| <!-- location should have relatedNode--> |
| <location var="location" obj="error"/> |
| <relatedNode var="problemNode" obj="location" interface="DOMLocator"/> |
| <assertSame actual="problemNode" expected="newChild" id="relatedNode"/> |
| <!-- |
| can't make assertions about these values |
| --> |
| <lineNumber var="lineNumber" obj="location"/> |
| <columnNumber var="columnNumber" obj="location"/> |
| <byteOffset var="byteOffset" obj="location"/> |
| <utf16Offset var="utf16Offset" obj="location"/> |
| <uri var="uri" obj="location" interface="DOMLocator"/> |
| <increment var="splittedCount" value="1"/> |
| <else> |
| <assertEquals actual="severity" expected="1" ignoreCase="false" id="anyOthersShouldBeWarnings"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="splittedCount" expected="1" ignoreCase="false" id="oneSplittedWarning"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument07.xml |
|---|
| 0,0 → 1,116 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument07"> |
| <metadata> |
| <title>documentnormalizedocument07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add a CDATASection containing "]]>" and perform normalization with split-cdata-sections=false. Should result |
| in an error. |
| </description> |
| <date qualifier="created">2004-01-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-split-cdata-sections"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-severity"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-message"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-relatedException"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-relatedData"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ERROR-DOMError-location"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-line-number"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-column-number"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-byteOffset"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-utf16Offset"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-node"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMLocator-uri"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=542"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="newChild" type="CDATASection"/> |
| <var name="oldChild" type="Node"/> |
| <var name="retval" type="Node"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <var name="problemNode" type="Node"/> |
| <var name="location" type="DOMLocator"/> |
| <var name="lineNumber" type="int"/> |
| <var name="columnNumber" type="int"/> |
| <var name="byteOffset" type="int"/> |
| <var name="utf16Offset" type="int"/> |
| <var name="uri" type="DOMString"/> |
| <var name="type" type="DOMString"/> |
| <var name="message" type="DOMString"/> |
| <var name="relatedException" type="DOMObject"/> |
| <var name="relatedData" type="DOMObject"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <firstChild var="oldChild" obj="elem" interface="Node"/> |
| <createCDATASection var="newChild" obj="doc" data='"this is not ]]> good"'/> |
| <replaceChild var="retval" obj="elem" newChild="newChild" oldChild="oldChild"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"split-cdata-sections"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <if> |
| <equals actual="severity" expected='2' ignoreCase="false"/> |
| <!-- location should have relatedNode --> |
| <location var="location" obj="error"/> |
| <relatedNode var="problemNode" obj="location" interface="DOMLocator"/> |
| <assertSame actual="problemNode" expected="newChild" id="relatedNode"/> |
| <!-- |
| can't make assertions about these values |
| --> |
| <lineNumber var="lineNumber" obj="location"/> |
| <columnNumber var="columnNumber" obj="location"/> |
| <byteOffset var="byteOffset" obj="location"/> |
| <utf16Offset var="utf16Offset" obj="location"/> |
| <uri var="uri" obj="location" interface="DOMLocator"/> |
| <!-- message should be non-empty --> |
| <message var="message" obj="error"/> |
| <length var="length" obj="message" interface="DOMString"/> |
| <assertTrue id="messageNotEmpty"> |
| <greater actual="length" expected="0"/> |
| </assertTrue> |
| <!-- can't make any assertions about type or relatedData |
| other than access should not raise exception --> |
| <type var="type" obj="error" interface="DOMError"/> |
| <relatedData var="relatedData" obj="error"/> |
| <relatedException var="relatedException" obj="error"/> |
| <increment var="errorCount" value="1"/> |
| <else> |
| <assertEquals actual="severity" expected="1" ignoreCase="false" id="anyOthersShouldBeWarnings"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument08.xml |
|---|
| 0,0 → 1,78 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument08"> |
| <metadata> |
| <title>documentnormalizedocument08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add two CDATASections containing "]]>" perform normalization with split-cdata-sections=true. |
| Should result in two warnings and at least 4 nodes. |
| </description> |
| <date qualifier="created">2004-01-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-split-cdata-sections"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="newChild" type="CDATASection"/> |
| <var name="oldChild" type="Node"/> |
| <var name="retval" type="Node"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="length" type="int"/> |
| <var name="childNodes" type="NodeList"/> |
| <var name="type" type="DOMString"/> |
| <var name="splittedCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <createCDATASection var="newChild" obj="doc" data='"this is not ]]> good"'/> |
| <firstChild var="oldChild" obj="elem" interface="Node"/> |
| <replaceChild var="retval" obj="elem" newChild="newChild" oldChild="oldChild"/> |
| <createCDATASection var="newChild" obj="doc" data='"this is not ]]> good"'/> |
| <appendChild var="retval" obj="elem" newChild="newChild"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"split-cdata-sections"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <type var="type" obj="error" interface="DOMError"/> |
| <severity var="severity" obj="error"/> |
| <if> |
| <equals actual="type" expected='"cdata-sections-splitted"' ignoreCase="false"/> |
| <increment var="splittedCount" value="1"/> |
| <else> |
| <assertEquals actual="severity" expected="1" ignoreCase="false" id="anyOthersShouldBeWarnings"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="splittedCount" expected="2" ignoreCase="false" id="twoSplittedWarning"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <childNodes var="childNodes" obj="elem"/> |
| <length var="length" obj="childNodes" interface="NodeList"/> |
| <assertTrue id="atLeast4ChildNodes"><greater actual="length" expected="3"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument09.xml |
|---|
| 0,0 → 1,70 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument09"> |
| <metadata> |
| <title>documentnormalizedocument09</title> |
| <creator>IBM</creator> |
| <description> |
| The normalizeDocument method method acts as if the document was going through a save |
| and load cycle, putting the document in a "normal" form. |
| Set the validate-if-schema feature to true. Invoke the normalizeDocument method on this |
| document. Retreive the documentElement node and check the nodeName of this node |
| to make sure it has not changed. Now set validate to false and verify the same. |
| Register an error handler on this Document and in each case make sure that it does |
| not get called. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate-if-schema"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemNodeName" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errorHandler" type="DOMErrorHandler"/> |
| <var name="errHandler" type="DOMErrorHandler"> |
| <handleError> |
| <assertFalse actual="true" id="documentnormalizedocument09_Err"/> |
| <return value="true"/> |
| </handleError> |
| </var> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errHandler"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"validate-if-schema"' value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"validate-if-schema"' value="true"/> |
| <normalizeDocument obj="doc"/> |
| <documentElement var="docElem" obj="doc"/> |
| <nodeName var="docElemNodeName" obj="docElem"/> |
| <assertEquals actual="docElemNodeName" expected='"html"' id="documentnormalizedocument09_True" ignoreCase="false"/> |
| </if> |
| <setParameter obj="domConfig" name='"validate-if-schema"' value="false"/> |
| <normalizeDocument obj="doc"/> |
| <documentElement var="docElem" obj="doc"/> |
| <nodeName var="docElemNodeName" obj="docElem"/> |
| <assertEquals actual="docElemNodeName" expected='"html"' id="documentnormalizedocument09_False" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument10.xml |
|---|
| 0,0 → 1,75 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument10"> |
| <metadata> |
| <title>documentnormalizedocument10</title> |
| <creator>IBM</creator> |
| <description> |
| The normalizeDocument method method acts as if the document was going through a save |
| and load cycle, putting the document in a "normal" form. |
| Create an Element and a text node and verify the nodeValue of this text node and append these to |
| this Document. If supported, invoke the setParameter method on this domconfiguration object to set the |
| "element-content-whitespace" feature to false. Invoke the normalizeDocument method and verify if |
| the text node has been discarded. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-element-content-whitespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="newText" type="Text"/> |
| <var name="text" type="Text"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElement var="elem" obj="doc" tagName='"newElem"'/> |
| <createTextNode var="newText" obj="doc" data='"Text |
| Node"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="newText"/> |
| <appendChild obj="doc" var="appendedChild" newChild="elem"/> |
| <firstChild var="text" obj="elem" interface="Node"/> |
| <nodeValue var="nodeValue" obj="text"/> |
| <assertEquals actual="nodeValue" expected='"Text |
| Node"' id="documentnormalizedocument10" ignoreCase="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"element-content-whitespace"' value="true"/> |
| <assertTrue actual="canSet" id="canSetElementContentWhitespaceTrue"/> |
| <setParameter obj="domConfig" name='"element-content-whitespace"' value="true"/> |
| <normalizeDocument obj="doc"/> |
| <firstChild var="text" obj="elem" interface="Node"/> |
| <nodeValue var="nodeValue" obj="text"/> |
| <assertEquals actual="nodeValue" expected='"Text |
| Node"' id="documentnormalizedocument10_true1" ignoreCase="false"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"element-content-whitespace"' value="false"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"element-content-whitespace"' value="false"/> |
| <normalizeDocument obj="doc"/> |
| <firstChild var="text" obj="elem" interface="Node"/> |
| <nodeValue var="nodeValue" obj="text"/> |
| <assertEquals actual="nodeValue" expected='"Text Node"' id="documentnormalizedocument10_true2" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument11.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument11"> |
| <metadata> |
| <title>documentnormalizedocument11</title> |
| <creator>IBM</creator> |
| <description> |
| The normalizeDocument method method acts as if the document was going through a save |
| and load cycle, putting the document in a "normal" form. |
| The feature namespace-declarations when set to false, discards all namespace declaration attributes, |
| although namespace prefixes are still retained. |
| Set the normalization feature "namespace-declarations" to false, invoke normalizeDocument and verify |
| the nodeName of element acquired by tagname. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespace-declarations"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="ignoringElementContentWhitespace" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elemName" type="Element"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"namespace-declarations"' value="true"/> |
| <normalizeDocument obj="doc"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" namespaceURI='"*"' localName='"acronym"' interface="Document"/> |
| <item var="elemName" obj="elemList" index="1" interface="NodeList"/> |
| <assertNotNull actual="elemName" id="documentnormalizedocument11_NotNullElem"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"namespace-declarations"' value="false"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"namespace-declarations"' value="false"/> |
| <normalizeDocument obj="doc"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" namespaceURI='"*"' localName='"acronym"' interface="Document"/> |
| <item var="elemName" obj="elemList" index="1" interface="NodeList"/> |
| <nodeName var="nodeName" obj="elemName"/> |
| <assertEquals actual="nodeName" expected='"address"' id="documentnormalizedocument11_namespaceDeclarations" ignoreCase="false"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument12.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument12"> |
| <metadata> |
| <title>documentnormalizedocument12</title> |
| <creator>IBM</creator> |
| <description> |
| The normalizeDocument method method acts as if the document was going through a save |
| and load cycle, putting the document in a "normal" form. |
| Set the validate feature to true. Invoke the normalizeDocument method on this |
| document. Retreive the documentElement node and check the nodeName of this node |
| to make sure it has not changed. Now set validate to false and verify the same. |
| Register an error handler on this Document and in each case make sure that it does |
| not get called. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemNodeName" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorHandler" type="DOMErrorHandler"/> |
| <var name="errHandler" type="DOMErrorHandler"> |
| <handleError> |
| <assertFalse actual="true" id="documentnormalizedocument08_Err"/> |
| <return value="true"/> |
| </handleError> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errHandler"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"validate"' value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <normalizeDocument obj="doc"/> |
| <documentElement var="docElem" obj="doc"/> |
| <nodeName var="docElemNodeName" obj="docElem"/> |
| <assertEquals actual="docElemNodeName" expected='"html"' id="documentnormalizedocument08_True" ignoreCase="false"/> |
| </if> |
| <setParameter obj="domConfig" name='"validate"' value="false"/> |
| <normalizeDocument obj="doc"/> |
| <documentElement var="docElem" obj="doc"/> |
| <nodeName var="docElemNodeName" obj="docElem"/> |
| <assertEquals actual="docElemNodeName" expected='"html"' id="documentnormalizedocument08_False" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentnormalizedocument13.xml |
|---|
| 0,0 → 1,103 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentnormalizedocument13"> |
| <metadata> |
| <title>documentnormalizedocument13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add a L1 attribute to a L2 namespace aware document and perform namespace normalization. Should result |
| in an error. |
| </description> |
| <date qualifier="created">2004-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms#normalizeDocumentAlgo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespaces"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="retval" type="Element"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <var name="problemNode" type="Node"/> |
| <var name="location" type="DOMLocator"/> |
| <var name="lineNumber" type="int"/> |
| <var name="columnNumber" type="int"/> |
| <var name="byteOffset" type="int"/> |
| <var name="utf16Offset" type="int"/> |
| <var name="uri" type="DOMString"/> |
| <var name="type" type="DOMString"/> |
| <var name="message" type="DOMString"/> |
| <var name="relatedException" type="DOMObject"/> |
| <var name="relatedData" type="DOMObject"/> |
| <var name="length" type="int"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <setAttribute obj="elem" name='"title"' value='"DOM L1 Attribute"'/> |
| <getAttributeNode var="newAttr" obj="elem" name='"title"'/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"namespaces"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <if> |
| <equals actual="severity" expected="2" ignoreCase="false"/> |
| <!-- location should have relatedNode, everything else should be -1 or null --> |
| <location var="location" obj="error"/> |
| <relatedNode var="problemNode" obj="location" interface="DOMLocator"/> |
| <assertSame actual="problemNode" expected="newAttr" id="relatedNodeIsL1Node"/> |
| <lineNumber var="lineNumber" obj="location"/> |
| <assertEquals actual="lineNumber" expected="-1" ignoreCase="false" id="lineNumber"/> |
| <columnNumber var="columnNumber" obj="location"/> |
| <assertEquals actual="columnNumber" expected="-1" ignoreCase="false" id="columnNumber"/> |
| <byteOffset var="byteOffset" obj="location"/> |
| <assertEquals actual="byteOffset" expected="-1" ignoreCase="false" id="byteOffset"/> |
| <utf16Offset var="utf16Offset" obj="location"/> |
| <assertEquals actual="utf16Offset" expected="-1" ignoreCase="false" id="utf16Offset"/> |
| <uri var="uri" obj="location" interface="DOMLocator"/> |
| <assertNull actual="uri" id="uri"/> |
| <!-- message and type should be non-empty --> |
| <message var="message" obj="error"/> |
| <length var="length" obj="message" interface="DOMString"/> |
| <assertTrue id="messageNotEmpty"> |
| <greater actual="length" expected="0"/> |
| </assertTrue> |
| <!-- can't make any assertions about type, relatedData and relatedException |
| other than access should not raise exception --> |
| <type var="type" obj="error" interface="DOMError"/> |
| <relatedData var="relatedData" obj="error"/> |
| <relatedException var="relatedException" obj="error"/> |
| <increment var="errorCount" value="1"/> |
| <else> |
| <assertEquals actual="severity" expected="1" ignoreCase="false" id="anyOthersShouldBeWarnings"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode01.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode01"> |
| <metadata> |
| <title>documentrenamenode01</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to rename the class attribute node of the |
| second element whose localName is acronym and namespaceURI http://www.nist.gov |
| with the new namespaceURI as http://www.w3.org/DOM/Test and name as pre0fix:renamedNode. |
| Check if this attribute has been renamed successfully by verifying the |
| nodeName, namespaceURI, nodeType attributes of the renamed node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="renamedclass" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="element" obj="childList" index="1" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="element" name='"class"'/> |
| <renameNode var="renamedclass" obj="doc" n="attr" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"renamedNode"'/> |
| <nodeName var="nodeName" obj="renamedclass"/> |
| <namespaceURI var="namespaceURI" obj="renamedclass" interface="Node"/> |
| <nodeType var="nodeType" obj="renamedclass"/> |
| <assertEquals expected='"renamedNode"' actual="nodeName" id="documentrenameode01_nodeName" ignoreCase="false"/> |
| <assertEquals expected="2" actual="nodeType" id="documentrenameNode01_nodeType" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/DOM/Test"' actual="namespaceURI" id="documentrenamenode01_nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode02.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode02"> |
| <metadata> |
| <title>documentrenamenode02</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to rename the class attribute node of the |
| second element whose localName is acronym and namespaceURI http://www.nist.gov |
| with the new namespaceURI as http://www.w3.org/DOM/Test and name as prefi0x:renamedNode. |
| Check if this attribute has been renamed successfully by verifying the |
| nodeName, namespaceURI, nodeType attributes of the renamed node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="renamedclass" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="element" obj="childList" index="1" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="element" name='"class"'/> |
| <renameNode var="renamedclass" obj="doc" n="attr" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"prefi0x:renamedNode"'/> |
| <nodeName var="nodeName" obj="renamedclass"/> |
| <namespaceURI var="namespaceURI" obj="renamedclass" interface="Node"/> |
| <nodeType var="nodeType" obj="renamedclass"/> |
| <assertEquals expected='"prefi0x:renamedNode"' actual="nodeName" id="documentrenamenode02_nodeName" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/DOM/Test"' actual="namespaceURI" id="documentrenamenode02_namespaceURI" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode03.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode03"> |
| <metadata> |
| <title>documentrenamenode03</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to rename a new attribute node to one whose |
| namespaceURI is http://www.w3.org/DOM/Test and name is pre0:fix1. |
| Check if this attribute has been renamed successfully by verifying the |
| nodeName, namespaceURI, nodeType attributes of the renamed node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr" type="Attr"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI="nullNSURI" qualifiedName='"test"'/> |
| <renameNode var="renamedNode" obj="doc" n="attr" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"pre0:fix1"'/> |
| <nodeName var="nodeName" obj="renamedNode"/> |
| <namespaceURI var="namespaceURI" obj="renamedNode" interface="Node"/> |
| <assertEquals expected='"pre0:fix1"' actual="nodeName" id="documentrenamenode03_nodeName" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/DOM/Test"' actual="namespaceURI" id="documentrenamenode02_namespaceURI" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode04.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode04"> |
| <metadata> |
| <title>documentrenamenode04</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to rename a new attribute node to one whose |
| namespaceURI is null and name is pf. |
| Check if this attribute has been renamed successfully by verifying the |
| nodeName, namespaceURI, nodeType attributes of the renamed node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr" type="Attr"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <renameNode var="renamedNode" obj="doc" n="attr" namespaceURI='""' qualifiedName='"title"'/> |
| <nodeName var="nodeName" obj="renamedNode"/> |
| <namespaceURI var="namespaceURI" obj="renamedNode" interface="Node"/> |
| <assertEquals expected='"title"' actual="nodeName" id="documentrenamenode04_nodeName" ignoreCase="false"/> |
| <assertNull actual="namespaceURI" id="documentrenamenode04_namespaceURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode05.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode05"> |
| <metadata> |
| <title>documentrenamenode05</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to rename a new attribute node to one whose |
| namespaceURI is null and name is rened. |
| Check if this attribute has been renamed successfully by verifying the |
| nodeName, namespaceURI, nodeType attributes of the renamed node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr" type="Attr"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <renameNode var="renamedNode" obj="doc" n="attr" namespaceURI="nullNSURI" qualifiedName='"title"'/> |
| <nodeName var="nodeName" obj="renamedNode"/> |
| <namespaceURI var="namespaceURI" obj="renamedNode" interface="Node"/> |
| <assertNull actual="namespaceURI" id="documentrenamenode05_namespaceURI"/> |
| <assertEquals expected='"title"' actual="nodeName" id="documentrenamenode05_nodeName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode06.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode06"> |
| <metadata> |
| <title>documentrenamenode06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to rename the default attribute "dir" to xsi:schemaLocation. |
| Check if this attribute has been renamed successfully by verifying the |
| nodeName, namespaceURI, nodeType attributes of the renamed node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="renamedclass" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="element" obj="childList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="element" name='"dir"'/> |
| <renameNode var="renamedclass" obj="doc" n="attr" namespaceURI='"http://www.w3.org/2001/XMLSchema-instance"' qualifiedName='"xsi:schemaLocation"'/> |
| <nodeName var="nodeName" obj="renamedclass"/> |
| <namespaceURI var="namespaceURI" obj="renamedclass" interface="Node"/> |
| <nodeType var="nodeType" obj="renamedclass"/> |
| <assertEquals expected='"xsi:schemaLocation"' actual="nodeName" id="documentrenameode01_nodeName" ignoreCase="false"/> |
| <assertEquals expected="2" actual="nodeType" id="documentrenameNode01_nodeType" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/2001/XMLSchema-instance"' actual="namespaceURI" id="documentrenamenode01_nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode07.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode07"> |
| <metadata> |
| <title>documentrenamenode07</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method on a new document node to rename a new attribute node |
| to one whose namespaceURI is http://www.w3.org/XML/1998/namespace and name is xml:dom. |
| Check if this attribute has been renamed successfully by verifying the |
| nodeName and namespaceURI attributes of the renamed node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="attr" type="Attr"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createAttributeNS var="attr" obj="newDoc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <renameNode var="renamedNode" obj="newDoc" n="attr" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:dom"'/> |
| <nodeName var="nodeName" obj="renamedNode"/> |
| <namespaceURI var="namespaceURI" obj="renamedNode" interface="Node"/> |
| <assertEquals expected='"xml:dom"' actual="nodeName" id="documentrenamenode07_nodeName" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/XML/1998/namespace"' actual="namespaceURI" id="documentrenamenode07_namespaceURI" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode08.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode08"> |
| <metadata> |
| <title>documentrenamenode08</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method on a new document node and try to rename the default |
| attribute "dir" |
| Check if a WRONG_DOCUMENT_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="element" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemNS" type="DOMString"/> |
| <var name="docElemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="element" obj="childList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="element" name='"dir"'/> |
| <implementation var="domImpl" obj="doc"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="docElemNS" obj="docElem" interface="Node"/> |
| <tagName var="docElemName" obj="docElem"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='docElemNS' qualifiedName='docElemName' doctype="nullDocType"/> |
| <assertDOMException id="documentrenamenode08_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <renameNode var="renamedNode" obj="newDoc" n="attr" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode09.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode09"> |
| <metadata> |
| <title>documentrenamenode09</title> |
| <creator>IBM</creator> |
| <description> |
| The method renameNode renames an existing node. When the specified node was created |
| from a different document than this document, a WRONG_DOCUMENT_ERR exception is thrown. |
| Invoke the renameNode method on a new Document node to rename a new attribute node |
| created in the original Document, but later adopted by this new document node. The |
| ownerDocument attribute of this attribute has now changed, such that the attribute node is considered to |
| be created from this new document node. Verify that no exception is thrown upon renaming and verify |
| the new nodeName of this attribute node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="attr" type="Attr"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="adopted" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="attrNodeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom:newD"' doctype="nullDocType"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"test"'/> |
| <adoptNode obj="newDoc" var="adopted" source="attr"/> |
| <renameNode var="renamedNode" obj="newDoc" n="attr" namespaceURI='"http://www.w3.org/2000/xmlns/"' qualifiedName='"xmlns:xmlns"'/> |
| <nodeName var="attrNodeName" obj="renamedNode"/> |
| <assertEquals actual="attrNodeName" expected='"xmlns:xmlns"' id="documentrenamenode09_1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode10.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode10"> |
| <metadata> |
| <title>documentrenamenode10</title> |
| <creator>IBM</creator> |
| <description> |
| The method renameNode renames an existing node and raises a NAMESPACE_ERR |
| if the qualifiedName has a prefix and the namespaceURI is null but a |
| NOT_SUPPORTED_ERR should be raised since the the type of the specified node is |
| neither ELEMENT_NODE nor ATTRIBUTE_NODE. |
| Invoke the renameNode method on a new document node to rename a node to nodes |
| with malformed qualifiedNames. |
| Check if a NOT_SUPPORTED_ERR gets thrown instead of a NAMESPACE_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="textEntry" type="DOMString" value='"hello"'/> |
| <var name="textNode" type="Text"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="qualifiedNames" type="List"> |
| <member>"_:"</member> |
| <member>":0"</member> |
| <member>":"</member> |
| <member>"a0:0"</member> |
| <member>"_:0;"</member> |
| <member>"a:::::c"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createTextNode var="textNode" data="textEntry" obj="doc"/> |
| <for-each collection="qualifiedNames" member="qualifiedName"> |
| <assertDOMException id="documentrenamenode10_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedNode" obj="doc" n="textNode" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName="qualifiedName"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode11.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode11"> |
| <metadata> |
| <title>documentrenamenode11</title> |
| <creator>IBM</creator> |
| <description> |
| The method renameNode renames an existing node and raises a NAMESPACE_ERR |
| if the qualifiedName has a prefix and the namespaceURI is null but a |
| NOT_SUPPORTED_ERR should be raised since the the type of the specified node is |
| neither ELEMENT_NODE nor ATTRIBUTE_NODE. |
| Invoke the renameNode method on this document node to rename a text node such that its |
| qualifiedName has a prefix and namespaceURI is null. |
| Check if a NOT_SUPPORTED_ERR gets thrown instead of a NAMESPACE_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="textEntry" type="DOMString" value='"hello"'/> |
| <var name="textNode" type="Text"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createTextNode var="textNode" data="textEntry" obj="doc"/> |
| <assertDOMException id="documentrenamenode11_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedNode" obj="doc" n="textNode" namespaceURI="nullNSURI" qualifiedName='"pre:fix"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode12.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode12"> |
| <metadata> |
| <title>documentrenamenode12</title> |
| <creator>IBM</creator> |
| <description> |
| The method renameNode renames an existing node and raises a NAMESPACE_ERR |
| if the qualifiedName has a prefix and the namespaceURI is null but a |
| NOT_SUPPORTED_ERR should be raised since the the type of the specified node is |
| neither ELEMENT_NODE nor ATTRIBUTE_NODE. |
| Invoke the renameNode method on this document node to rename a text node such that its |
| qualifiedName has a prefix that is "xml" and namespaceURI is "http://www.w3.org/XML/1999/namespace". |
| Check if a NOT_SUPPORTED_ERR gets thrown instead of a NAMESPACE_ERR since the type of node is not valid |
| for this method. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="textEntry" type="DOMString" value='"hello"'/> |
| <var name="textNode" type="Text"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createTextNode var="textNode" data="textEntry" obj="doc"/> |
| <assertDOMException id="documentrenamenode12_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedNode" obj="doc" n="textNode" namespaceURI='"http://www.w3.org/XML/1999/namespace"' qualifiedName='"xml:prefix"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode13.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode13"> |
| <metadata> |
| <title>documentrenamenode13</title> |
| <creator>IBM</creator> |
| <description> |
| The method renameNode renames an existing node and raises a NAMESPACE_ERR |
| if the qualifiedName has a prefix and the namespaceURI is null but a |
| NOT_SUPPORTED_ERR should be raised since the the type of the specified node is |
| neither ELEMENT_NODE nor ATTRIBUTE_NODE. |
| Invoke the renameNode method on this document node to rename a text node such that its |
| qualifiedName has a prefix that is "xmlns"and namespaceURI is "http://www.w3.org/XML/1998/namespace". |
| Check if a NOT_SUPPORTED_ERR gets thrown instead of a NAMESPACE_ERR since the type of node is not valid |
| for this method. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="textEntry" type="DOMString" value='"hello"'/> |
| <var name="textNode" type="Text"/> |
| <var name="renamedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createTextNode var="textNode" data="textEntry" obj="doc"/> |
| <assertDOMException id="documentrenamenode13_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedNode" obj="doc" n="textNode" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xmlns:prefix"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode14.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode14"> |
| <metadata> |
| <title>documentrenamenode14</title> |
| <creator>IBM</creator> |
| <description> |
| The method renameNode renames an existing node and raises a NAMESPACE_ERR |
| if the qualifiedName has a prefix and the namespaceURI is null but a |
| NOT_SUPPORTED_ERR should be raised since the the type of the specified node is |
| neither ELEMENT_NODE nor ATTRIBUTE_NODE. |
| Invoke the renameNode method on this document node to rename a text node such that its |
| qualifiedName is "xmlns"and namespaceURI is "http://www.w3.org/2000/xmlns". |
| Check if a NOT_SUPPORTED_ERR gets thrown instead of a NAMESPACE_ERR since the type of node is |
| not valid for this method. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="textEntry" type="DOMString" value='"hello"'/> |
| <var name="textNode" type="Text"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createTextNode var="textNode" data="textEntry" obj="doc"/> |
| <assertDOMException id="documentrenamenode14_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedNode" obj="doc" n="textNode" namespaceURI='"http://www.w3.org/2000/xmlns"' qualifiedName='"xmlns"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode15.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode15"> |
| <metadata> |
| <title>documentrenamenode15</title> |
| <creator>IBM</creator> |
| <description> |
| Rename the fourth acronym element to svg:rect and verify the |
| nodeName, namespaceURI, nodeType attributes of the renamed node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="renamedclass" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="element" obj="childList" index="3" interface="NodeList"/> |
| <renameNode var="renamedclass" obj="doc" n="element" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"qnam:renamedNode"'/> |
| <nodeName var="nodeName" obj="renamedclass"/> |
| <namespaceURI var="namespaceURI" obj="renamedclass" interface="Node"/> |
| <nodeType var="nodeType" obj="renamedclass"/> |
| <assertEquals expected='"qnam:renamedNode"' actual="nodeName" id="documentrenamenode15_nodeName" ignoreCase="false"/> |
| <assertEquals expected="1" actual="nodeType" id="documentrenamenode15_nodeType" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/DOM/Test"' actual="namespaceURI" id="documentrenamenode15_nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode16.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode16"> |
| <metadata> |
| <title>documentrenamenode16</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to rename the fourth |
| acronym element with a new namespaceURI that is |
| null and qualifiedName that is renamedNode. |
| Check if this element has been renamed successfully by verifying the |
| nodeName, attributes of the renamed node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="renamedclass" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="element" obj="childList" index="3" interface="NodeList"/> |
| <renameNode var="renamedclass" obj="doc" n="element" namespaceURI="nullNSURI" qualifiedName='"renamedNode"'/> |
| <nodeName var="nodeName" obj="renamedclass"/> |
| <namespaceURI var="namespaceURI" obj="renamedclass" interface="Node"/> |
| <nodeType var="nodeType" obj="renamedclass"/> |
| <assertEquals expected='"renamedNode"' actual="nodeName" id="documentrenamenode16_nodeName" ignoreCase="false"/> |
| <assertEquals expected="1" actual="nodeType" id="documentrenamenode16_nodeType" ignoreCase="false"/> |
| <assertNull actual="namespaceURI" id="documentrenamenode16_nodeValue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode17.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode17"> |
| <metadata> |
| <title>documentrenamenode17</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to rename a new element node of a new document so that |
| its namespaceURI is http://www.w3.org/2000/xmlns/ and qualifiedName is xmlns:xmlns. |
| Check if this element has been renamed successfully by verifying the |
| nodeName, attributes of the renamed node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="element" type="Element"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootTagname" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootTagname" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='rootNS' qualifiedName='rootTagname' doctype="nullDocType"/> |
| <createElementNS var="element" obj="newDoc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"body"'/> |
| <renameNode var="renamedNode" obj="newDoc" n="element" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:head"'/> |
| <nodeName var="nodeName" obj="renamedNode"/> |
| <namespaceURI var="namespaceURI" obj="renamedNode" interface="Node"/> |
| <nodeType var="nodeType" obj="renamedNode"/> |
| <assertEquals expected='"xhtml:head"' actual="nodeName" id="documentrenamenode16_nodeName" ignoreCase="false"/> |
| <assertEquals expected="1" actual="nodeType" id="documentrenamenode16_nodeType" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/1999/xhtml"' actual="namespaceURI" id="documentrenamenode16_nodeValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode18.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode18"> |
| <metadata> |
| <title>documentrenamenode18</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method on this document and try to rename a new element |
| node of a new document. |
| Check if a WRONG_DOCUMENT_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="element" type="Element"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootTagname" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootTagname" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='rootNS' qualifiedName='rootTagname' doctype="nullDocType"/> |
| <createElementNS var="element" obj="newDoc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"body"'/> |
| <assertDOMException id="documentrenamenode18_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <renameNode var="renamedNode" obj="doc" n="element" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"head"'/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode19.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode19"> |
| <metadata> |
| <title>documentrenamenode19</title> |
| <creator>IBM</creator> |
| <description> |
| The method renameNode renames an existing node and raises a NAMESPACE_ERR |
| if the qualifiedName is malformed per the Namespaces in XML specification. |
| Invoke the renameNode method on a new document node to rename a node to nodes |
| with malformed qualifiedNames. |
| Check if a NAMESPACE_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="element" type="Element"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="qualifiedName" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="qualifiedNames" type="List"> |
| <member>"a_:"</member> |
| <member>"_:"</member> |
| <member>":"</member> |
| <member>"::0;"</member> |
| <member>"a:-:c"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"newD"' doctype="nullDocType"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"test"'/> |
| <for-each collection="qualifiedNames" member="qualifiedName"> |
| <assertDOMException id="documentrenamenode19_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <renameNode var="renamedNode" obj="doc" n="element" namespaceURI='"http://www.w3.org/2000/XMLNS"' qualifiedName="qualifiedName"/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode20.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode20"> |
| <metadata> |
| <title>documentrenamenode20</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method on this document node to rename a node such that its |
| qualifiedName has a prefix that is "xml:html" and namespaceURI is |
| "http://www.example.com/namespace". |
| Check if a NAMESPACE_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootTagname" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootTagname" obj="docElem"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootTagname" obj="docElem"/> |
| <createElementNS var="element" obj="doc" namespaceURI='rootNS' qualifiedName='rootTagname'/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <renameNode var="renamedNode" obj="doc" n="element" namespaceURI='"http://www.example.com/xml"' qualifiedName='"xml:html"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode21.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode21"> |
| <metadata> |
| <title>documentrenamenode21</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method on this document node to rename a node such that its |
| qualifiedName has a prefix that is "xmlns:xml"and namespaceURI is "http://www.w3.org/2000/XMLNS/". |
| Check if a NAMESPACE_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="attr" type="Attr"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createAttributeNS var="attr" obj="newDoc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <renameNode var="renamedNode" obj="newDoc" n="attr" namespaceURI='"http://www.w3.org/2000/XMLNS/"' qualifiedName='"xmlns:xml"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode22.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode22"> |
| <metadata> |
| <title>documentrenamenode22</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method on this document node to rename a node such that its |
| qualifiedName is "xmlns"and namespaceURI is "http://www.w3.org/1999/xmlns/". |
| Check if a NAMESPACE_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr" type="Attr"/> |
| <var name="renamedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <renameNode var="renamedNode" obj="doc" n="attr" namespaceURI='"http://www.w3.org/1999/xmlns/"' qualifiedName='"xmlns"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode23.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode23"> |
| <metadata> |
| <title>documentrenamenode23</title> |
| <creator>IBM</creator> |
| <description> |
| The method renameNode renames an existing node and raises a NOT_SUPPORTED_ERR |
| if the type of the specified node is neither ELEMENT_NODE nor ATTRIBUTE_NODE. |
| Invoke the renameNode method on this document node to attempt to rename itself. |
| Check if a NOT_SUPPORTED_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="docowner" type="Document"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <assertDOMException id="documentrenamenode23_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedNode" obj="doc" n="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"root"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode24.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode24"> |
| <metadata> |
| <title>documentrenamenode24</title> |
| <creator>IBM</creator> |
| <description> |
| The method renameNode renames an existing node and raises a NOT_SUPPORTED_ERR |
| if the type of the specified node is neither ELEMENT_NODE nor ATTRIBUTE_NODE. |
| Invoke the renameNode method on this document node to attempt to rename itself. |
| The namespaceURI specified here is null and the name has a prefix. |
| Check if a NOT_SUPPORTED_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="renamedNode" type="Node"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <var name="docowner" type="Document"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <assertDOMException id="documentrenamenode24_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedNode" obj="doc" n="doc" namespaceURI="nullNSURI" qualifiedName='"doc:root"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode25.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode25"> |
| <metadata> |
| <title>documentrenamenode25</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to attempt to rename a DOcumentType node of this Document. |
| Check if a NOT_SUPPORTED_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="renamedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <assertDOMException id="documentrenamenode25_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedNode" obj="doc" n="docType" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"root"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode26.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode26"> |
| <metadata> |
| <title>documentrenamenode26</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method oto attempt to rename a new DocumentFragment node |
| of this Document. |
| Check if a NOT_SUPPORTED_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="renamedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <assertDOMException id="documentrenamenode26_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedNode" obj="doc" n="docFrag" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"root"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode27.xml |
|---|
| 0,0 → 1,86 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode27"> |
| <metadata> |
| <title>documentrenamenode27</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to attempt to rename new Text, Comment, CDataSection, |
| ProcessingInstruction and EntityReference nodes of a new Document. |
| Check if a NOT_SUPPORTED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="text" type="Text"/> |
| <var name="comment" type="Comment"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="entref" type="EntityReference"/> |
| <var name="renamedTxt" type="Node"/> |
| <var name="renamedComment" type="Node"/> |
| <var name="renamedCdata" type="Node"/> |
| <var name="renamedPi" type="Node"/> |
| <var name="renamedEntRef" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createTextNode var="text" obj="newDoc" data='"text"'/> |
| <createComment var="comment" obj="newDoc" data='"comment"'/> |
| <createCDATASection var="cdata" obj="newDoc" data='"cdata"'/> |
| <createProcessingInstruction var="pi" obj="newDoc" target='"pit"' data='"pid"'/> |
| <createEntityReference var="entref" obj="newDoc" name='"alpha"'/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_1"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedTxt" obj="newDoc" n="text" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"text"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_2"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedComment" obj="newDoc" n="comment" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"comment"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_3"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedCdata" obj="newDoc" n="cdata" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"cdata"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_4"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedPi" obj="newDoc" n="pi" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"pi"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_5"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedEntRef" obj="newDoc" n="entref" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"entref"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode28.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode28"> |
| <metadata> |
| <title>documentrenamenode28</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to attempt to rename a Entity and Notation nodes of this Document. |
| Check if a NOT_SUPPORTED_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entityNodeMap" type="NamedNodeMap"/> |
| <var name="notationNodeMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="notation" type="Notation"/> |
| <var name="renamedEntityNode" type="Node"/> |
| <var name="renamedNotationNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entityNodeMap" obj="docType"/> |
| <notations var="notationNodeMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entityNodeMap" name='"alpha"'/> |
| <getNamedItem var="notation" obj="notationNodeMap" name='"notation1"'/> |
| <assertDOMException id="documentrenamenode28_ENTITY_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedEntityNode" obj="doc" n="entity" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"beta"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <assertDOMException id="documentrenamenode28_NOTATION_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <renameNode var="renamedNotationNode" obj="doc" n="notation" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"notation2"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentrenamenode29.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentrenamenode29"> |
| <metadata> |
| <title>documentrenamenode29</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the renameNode method to attempt to rename an Element node of a XML1.0 document |
| with a name that contains an invalid XML 1.0 character and check if a INVALID_CHARACTER_ERR |
| gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-renameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="renamed" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <assertDOMException id="documentrenamenode29_ENTITY_NOT_SUPPORTED_ERR"> |
| <INVALID_CHARACTER_ERR> |
| <renameNode var="renamed" obj="doc" n="docElem" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"@"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetdocumenturi01.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetdocumenturi01"> |
| <metadata> |
| <title>documentsetdocumenturi01</title> |
| <creator>IBM</creator> |
| <description> |
| The setDocmentURI method set the location of the document. |
| Set the documentURI to a valid string and retreive the documentURI of this |
| document and verify if it is was correctly set. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-documentURI"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentURI obj="doc" value='"file:///test"'/> |
| <documentURI var="docURI" obj="doc" /> |
| <assertEquals actual="docURI" expected='"file:///test"' id="documentsetdocumenturi01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetdocumenturi02.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetdocumenturi02"> |
| <metadata> |
| <title>documentsetdocumenturi02</title> |
| <creator>IBM</creator> |
| <description> |
| The setDocmentURI method set the location of the document. |
| Set the documentURI to null and retreive the documentURI of this document and verify |
| if it is was set to null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-documentURI"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docURI" type="DOMString"/> |
| <var name="nullValue" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentURI obj="doc" value="nullValue"/> |
| <documentURI var="docURI" obj="doc" /> |
| <assertNull actual="docURI" id="documentsetdocumenturi02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetdocumenturi03.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetdocumenturi03"> |
| <metadata> |
| <title>documentsetdocumenturi03</title> |
| <creator>IBM</creator> |
| <description> |
| The setDocmentURI method set the location of the document. |
| Create a new document and set its documentURI to a valid string. Retreive the documentURI |
| and verify if it is was correctly set. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-documentURI"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docURI" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <documentURI obj="newDoc" value='"somestring"'/> |
| <documentURI var="docURI" obj="newDoc" /> |
| <assertEquals actual="docURI" expected='"somestring"' id="documentsetdocumenturi03" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetstricterrorchecking01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetstricterrorchecking01"> |
| <metadata> |
| <title>documentsetstricterrorchecking01</title> |
| <creator>IBM</creator> |
| <description> |
| Set the strictErrorChecking attribute value on this documentNode to false and then to true. |
| Call the createAttributeNS method on this document with an illegal character in the qualifiedName |
| and check if the INVALID_CHARACTER_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-strictErrorChecking"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <strictErrorChecking obj="doc" value="false"/> |
| <strictErrorChecking obj="doc" value="true"/> |
| <assertDOMException id="INVALID_CHARACTER_ERR_documentsetstricterrorchecking01"> |
| <INVALID_CHARACTER_ERR> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"@"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetstricterrorchecking02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetstricterrorchecking02"> |
| <metadata> |
| <title>documentsetstricterrorchecking02</title> |
| <creator>IBM</creator> |
| <description> |
| Set the strictErrorChecking attribute value on a new Document to true. |
| Call the createAttributeNS method on this document with a a null namespaceURI and a qualified name |
| with a prefix and check if the NAMESPACE_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-strictErrorChecking"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="nullValue" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <strictErrorChecking obj="doc" value="true"/> |
| <assertDOMException id="NAMESPACE_ERR_documentsetstricterrorchecking02"> |
| <NAMESPACE_ERR> |
| <createAttributeNS obj="doc" var="newAttr" namespaceURI="nullValue" qualifiedName='"dom:test"'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetstricterrorchecking03.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetstricterrorchecking03"> |
| <metadata> |
| <title>documentsetstricterrorchecking03</title> |
| <creator>IBM</creator> |
| <description> |
| Set the strictErrorChecking attribute value on a new Document to false and check if it was |
| correctly set using getStrictErrorChecking. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-strictErrorChecking"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="strictErrorCheckingValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <strictErrorChecking obj="doc" value="false"/> |
| <strictErrorChecking var="strictErrorCheckingValue" obj="doc" /> |
| <assertFalse actual="strictErrorCheckingValue" id="documentsetstricterrorchecking03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetxmlstandalone01.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetxmlstandalone01"> |
| <metadata> |
| <title>documentsetxmlstandalone01</title> |
| <creator>IBM</creator> |
| <description> |
| Set the standalone attribute of this document to true and verify if the attribute was correctly |
| set. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-standalone"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="standalone" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <xmlStandalone obj="doc" value="true"/> |
| <xmlStandalone var="standalone" obj="doc" /> |
| <assertTrue actual="standalone" id="documentsetxmlstandalone01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetxmlstandalone02.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetxmlstandalone02"> |
| <metadata> |
| <title>documentsetxmlstandalone02</title> |
| <creator>IBM</creator> |
| <description> |
| Create a new document object and set standalone to false and check if it was correctly set. |
| Then repeat this by setting it to true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-standalone"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="standalone" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <xmlStandalone obj="newDoc" value="false"/> |
| <xmlStandalone var="standalone" obj="newDoc"/> |
| <assertFalse actual="standalone" id="documentsetxmlstandalone02_false"/> |
| <xmlStandalone obj="newDoc" value="true"/> |
| <xmlStandalone var="standalone" obj="newDoc"/> |
| <assertTrue actual="standalone" id="documentsetxmlstandalone02_true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetxmlversion01.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetxmlversion01"> |
| <metadata> |
| <title>documentsetxmlversion01</title> |
| <creator>IBM</creator> |
| <description> |
| Set the value of the version attribute of the XML declaration of this document to |
| various invalid characters and verify if a NOT_SUPPORTED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-version"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="versionValue" type="DOMString"/> |
| <var name="illegalVersion" type="List"> |
| <member>"{"</member> |
| <member>"}"</member> |
| <member>"~"</member> |
| <member>"'"</member> |
| <member>"!"</member> |
| <member>"@"</member> |
| <member>"#"</member> |
| <member>"$"</member> |
| <member>"%"</member> |
| <member>"^"</member> |
| <member>"&"</member> |
| <member>"*"</member> |
| <member>"("</member> |
| <member>")"</member> |
| <member>"+"</member> |
| <member>"="</member> |
| <member>"["</member> |
| <member>"]"</member> |
| <member>"\\"</member> |
| <member>"/"</member> |
| <member>";"</member> |
| <member>"`"</member> |
| <member>"<"</member> |
| <member>">"</member> |
| <member>","</member> |
| <member>"a "</member> |
| <member>"\""</member> |
| <member>"---"</member> |
| </var> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <for-each collection="illegalVersion" member="versionValue"> |
| <assertDOMException id="NOT_SUPPORTED_ERR_documentsetversion01"> |
| <NOT_SUPPORTED_ERR> |
| <xmlVersion obj="doc" value='versionValue' interface="Document"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetxmlversion02.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetxmlversion02"> |
| <metadata> |
| <title>documentsetxmlversion02</title> |
| <creator>IBM</creator> |
| <description> |
| Set the value of the version attribute of the XML declaration of a new document to "1.0" |
| and check if it was correctly set. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-version"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="versionValue" type="DOMString"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <xmlVersion obj="newDoc" value='"1.0"' interface="Document"/> |
| <xmlVersion var="versionValue" obj="newDoc" interface="Document"/> |
| <assertEquals actual="versionValue" expected='"1.0"' id="documentsetxmlversion02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetxmlversion03.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetxmlversion03"> |
| <metadata> |
| <title>documentsetxmlversion03</title> |
| <creator>IBM</creator> |
| <description> |
| Set the value of the version attribute of the XML declaration of a new document to "1.0" |
| and check if it was correctly set. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2003-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-version"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="versionValue" type="DOMString"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <xmlVersion obj="newDoc" value='"1.1"' interface="Document"/> |
| <xmlVersion var="versionValue" obj="newDoc" interface="Document"/> |
| <assertEquals actual="versionValue" expected='"1.1"' id="documentsetxmlversion03" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/documentsetxmlversion05.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="documentsetxmlversion05"> |
| <metadata> |
| <title>documentsetxmlversion05</title> |
| <creator>IBM</creator> |
| <description> |
| Set the value of the version attribute of the XML declaration of a new document to "-" |
| and check if a NOT_SUPPORTED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-version"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <xmlVersion obj="newDoc" value='"-"' interface="Document"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigcanonicalform1.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigcanonicalform1"> |
| <metadata> |
| <title>domconfigcanonicalform1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "canonical-form" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-property"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"cAnOnical-form"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <!-- should still be false after failed attempt --> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setTrueNotEffective"/> |
| </else> |
| </if> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigcdatasections1.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigcdatasections1"> |
| <metadata> |
| <title>domconfigcdatasections1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "cdata-sections" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-cdata-sections"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"cDaTa-sections"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setFalseEffective"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigcheckcharacternormalization1.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigcheckcharacternormalization1"> |
| <metadata> |
| <title>domconfigcheckcharacternormalization1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "check-character-normalization" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-check-character-normalization"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"cHeCk-character-normalization"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <!-- should still be false after failed attempt --> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setTrueNotEffective"/> |
| </else> |
| </if> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigcomments1.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigcomments1"> |
| <metadata> |
| <title>domconfigcomments1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "comments" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-comments"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"cOmments"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setFalseEffective"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigdatatypenormalization1.xml |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigdatatypenormalization1"> |
| <metadata> |
| <title>domconfigdatatypenormalization1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "datatype-normalization" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"dAtAtype-normalization"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <!-- should still be false after failed attempt --> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setTrueNotEffective"/> |
| </else> |
| </if> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigdatatypenormalization2.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigdatatypenormalization2"> |
| <metadata> |
| <title>domconfigdatatypenormalization2</title> |
| <creator>Curt Arnold</creator> |
| <description>Setting "datatype-normalization" to true also forces "validate" to true.</description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"datatype-normalization"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <!-- set validate to false --> |
| <setParameter obj="domConfig" name='"validate"' value="false"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name='"validate"'/> |
| <assertTrue actual="state" id="validateSet"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigelementcontentwhitespace1.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigelementcontentwhitespace1"> |
| <metadata> |
| <title>domconfigelementcontentwhitespace1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "element-content-whitespace" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-element-content-whitespace"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"eLeMent-content-whitespace"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setFalseEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <!-- should still be true after failed attempt --> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setFalseNotEffective"/> |
| </else> |
| </if> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigentities1.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigentities1"> |
| <metadata> |
| <title>domconfigentities1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "entities" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"eNtIties"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setFalseEffective"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigerrorhandler1.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigerrorhandler1"> |
| <metadata> |
| <title>domconfigerrorhandler1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "error-handler" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-error-handler"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=544"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="origHandler" type="DOMErrorHandler"/> |
| <var name="state" type="DOMErrorHandler"/> |
| <var name="parameter" type="DOMString" value='"eRrOr-handler"'/> |
| <var name="errorHandler" type="DOMErrorHandler"> |
| <handleError> |
| <return value="true"/> |
| </handleError> |
| </var> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="origHandler" obj="domConfig" name="parameter"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="errorHandler"/> |
| <assertTrue actual="canSet" id="canSetNewHandler"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="origHandler"/> |
| <assertTrue actual="canSet" id="canSetOrigHandler"/> |
| <setParameter obj="domConfig" name="parameter" value="errorHandler"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertSame expected="errorHandler" actual="state" id="setToNewHandlerEffective"/> |
| <setParameter obj="domConfig" name="parameter" value="origHandler"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertSame expected="origHandler" actual="state" id="setToOrigHandlerEffective"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <!-- |
| should return false for strongly typed languages |
| however if weakly typed, then should be consistent with setParameter |
| --> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigerrorhandler2.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigerrorhandler2"> |
| <metadata> |
| <title>domconfigerrorhandler2</title> |
| <creator>Curt Arnold</creator> |
| <description>Calls DOMConfiguration.setParameter("error-handler", null). Spec |
| does not explicitly address the case.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-error-handler"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errorHandler" type="DOMErrorHandler" isNull="true"/> |
| <var name="parameter" type="DOMString" value='"error-handler"'/> |
| <var name="state" type="DOMErrorHandler"/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="errorHandler"/> |
| <assertTrue actual="canSet" id="canSetNull"/> |
| <setParameter obj="domConfig" name="parameter" value="errorHandler"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertNull actual="state" id="errorHandlerIsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfiginfoset1.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfiginfoset1"> |
| <metadata> |
| <title>domconfiginfoset1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "infoset" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-cdata-sections"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"iNfOset"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <!-- default for infoset is false since entities default is true --> |
| <assertFalse actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueIsEffective"/> |
| <getParameter var="state" obj="domConfig" name='"entities"'/> |
| <assertFalse actual="state" id="entitiesSetFalse"/> |
| <getParameter var="state" obj="domConfig" name='"cdata-sections"'/> |
| <assertFalse actual="state" id="cdataSectionsSetFalse"/> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setFalseIsNoOp"/> |
| <setParameter obj="domConfig" name='"entities"' value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setEntitiesTrueInvalidatesInfoset"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfignamespacedeclarations1.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfignamespacedeclarations1"> |
| <metadata> |
| <title>domconfigcomments1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "namespace-declarations" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespace-declarations"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"nAmEspace-declarations"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setFalseEffective"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfignamespaces1.xml |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfignamespaces1"> |
| <metadata> |
| <title>domconfignamespaces1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "namespaces" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespaces"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"nAmEspaces"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setFalseEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <!-- should still be true after failed attempt --> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setFalseNotEffective"/> |
| </else> |
| </if> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfignamespaces2.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfignamespaces2"> |
| <metadata> |
| <title>domconfignamespaces2</title> |
| <creator>Curt Arnold</creator> |
| <description>Document.getParameter("namespaces") should be true regardles if the |
| parse that created the document was namespace aware.</description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespaces"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name='"namespaces"'/> |
| <assertTrue actual="state" id="namespacesTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfignormalizecharacters1.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfignormalizecharacters1"> |
| <metadata> |
| <title>domconfignormalizecharacters1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "normalize-characters" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-normalize-characters"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"nOrMalize-characters"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <!-- should still be false after failed attempt --> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setTrueNotEffective"/> |
| </else> |
| </if> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigparameternames01.xml |
|---|
| 0,0 → 1,94 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigparameternames01"> |
| <metadata> |
| <title>domconfigparameternames01</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks getParameterNames and canSetParameter for Document.domConfig.</description> |
| <date qualifier="created">2004-01-22</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-domConfig"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-parameterNames"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-cdata-sections"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-check-character-normalization"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-comments"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-error-handler"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespaces"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespace-declarations"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-normalize-characters"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-split-cdata-sections"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate-if-schema"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-well-formed"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-element-content-whitespace"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="parameterNames" type="DOMStringList"/> |
| <var name="parameterName" type="DOMString"/> |
| <var name="matchCount" type="int" value="0"/> |
| <var name="paramValue" type="DOMUserData"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <domConfig var="config" obj="doc" interface="Document"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <parameterNames var="parameterNames" obj="config"/> |
| <assertNotNull actual="parameterNames" id="parameterNamesNotNull"/> |
| <for-each collection="parameterNames" member="parameterName"> |
| <!-- get the default value of this parameter --> |
| <getParameter var="paramValue" obj="config" name="parameterName"/> |
| <!-- should be able to set to default value --> |
| <canSetParameter var="canSet" obj="config" name="parameterName" value="paramValue"/> |
| <assertTrue actual="canSet" id="canSetToDefaultValue"/> |
| <setParameter obj="config" name="parameterName" value="paramValue"/> |
| <if> |
| <or> |
| <equals actual="parameterName" expected='"canonical-form"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"cdata-sections"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"check-character-normalization"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"comments"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"datatype-normalization"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"entities"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"error-handler"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"infoset"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"namespaces"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"namespace-declarations"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"normalize-characters"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"split-cdata-sections"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"validate"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"validate-if-schema"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"well-formed"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"element-content-whitespace"' ignoreCase="true"/> |
| </or> |
| <increment var="matchCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="matchCount" expected="16" id="definedParameterCount" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigschemalocation1.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigschemalocation1"> |
| <metadata> |
| <title>domconfigschemalocation1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "schema-location" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-location"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="DOMString"/> |
| <var name="parameter" type="DOMString" value='"sChEma-location"'/> |
| <var name="nullSchemaLocation" type="DOMString" isNull="true"/> |
| <var name="sampleSchemaLocation" type="DOMString" value='"http://www.example.com/schemas/sampleschema.xsd"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertFalse actual="canSet" id="canSetTrue"/> |
| <try> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertNull actual="state" id="defaultSchemaLocation"/> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="sampleSchemaLocation"/> |
| <assertTrue actual="canSet" id="canSetURI"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="nullSchemaLocation"/> |
| <assertTrue actual="canSet" id="canSetNull"/> |
| <setParameter obj="domConfig" name="parameter" value="sampleSchemaLocation"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertEquals actual="state" expected="sampleSchemaLocation" ignoreCase="false" id="setURIEffective"/> |
| <setParameter obj="domConfig" name="parameter" value="nullSchemaLocation"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertNull actual="state" id="setNullEffective"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigschematype1.xml |
|---|
| 0,0 → 1,80 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigschematype1"> |
| <metadata> |
| <title>domconfigschematype1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "schema-type" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="DOMString"/> |
| <var name="parameter" type="DOMString" value='"sChEma-type"'/> |
| <var name="xmlSchemaType" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="dtdType" type="DOMString" value='"http://www.w3.org/TR/REC-xml"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertFalse actual="canSet" id="canSetTrue"/> |
| <try> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="dtdType"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="dtdType"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertEquals actual="state" expected="dtdType" ignoreCase="false" id="setDTDEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_dtd"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="dtdType"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="xmlSchemaType"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="xmlSchemaType"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertEquals actual="state" expected="xmlSchemaType" ignoreCase="false" id="setSchemaEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_schema"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="xmlSchemaType"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigsplitcdatasections1.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigsplitcdatasections1"> |
| <metadata> |
| <title>domconfigsplitcdatasections1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "split-cdata-sections" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-split-cdata-sections"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"sPlIt-cdata-sections"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setFalseEffective"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigurationcansetparameter01.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigurationcansetparameter01"> |
| <metadata> |
| <title>domconfigurationcansetparameter01</title> |
| <creator>IBM</creator> |
| <description> |
| The parameter commments is turned on by default. Check to see if this feature can be set |
| to false by invoking canSetParameter method. Also check that this method does not change the |
| value of parameter. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-11-06</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-canSetParameter"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="newCommentNode" type="Comment"/> |
| <var name="docElem" type="Element"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="lastChild" type="Node"/> |
| <var name="commentValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createComment obj="doc" var="newCommentNode" data='"This is a new Comment node"'/> |
| <documentElement obj="doc" var="docElem" interface="Document"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="newCommentNode" interface="Node"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter obj="domConfig" var="canSet" name='"comments"' value="false"/> |
| <assertTrue actual="canSet" id="domconfigurationcansetparameter01"/> |
| <normalizeDocument obj="doc"/> |
| <lastChild obj="docElem" var="lastChild" interface="Node"/> |
| <nodeValue obj="lastChild" var="commentValue" interface="Node"/> |
| <assertEquals actual="commentValue" expected='"This is a new Comment node"' id="domconfigurationsetparameter02_2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigurationcansetparameter02.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigurationcansetparameter02"> |
| <metadata> |
| <title>domconfigurationcansetparameter02</title> |
| <creator>IBM</creator> |
| <description> |
| Check that canSetParameter('cdata-sections') returns true for both true and false |
| and that calls to the method do not actually change the parameter value. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-11-06</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-canSetParameter"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="paramVal" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter obj="domConfig" var="canSet" name='"cdata-sections"' value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <getParameter var="paramVal" obj="domConfig" name='"cdata-sections"'/> |
| <assertTrue actual="paramVal" id="valueStillTrue"/> |
| <canSetParameter obj="domConfig" var="canSet" name='"cdata-sections"' value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="false"/> |
| <canSetParameter obj="domConfig" var="canSet" name='"cdata-sections"' value="true"/> |
| <assertTrue actual="canSet" id="canSetTrueFromFalse"/> |
| <getParameter var="paramVal" obj="domConfig" name='"cdata-sections"'/> |
| <assertFalse actual="paramVal" id="valueStillFalse"/> |
| <canSetParameter obj="domConfig" var="canSet" name='"cdata-sections"' value="false"/> |
| <assertTrue actual="canSet" id="canSetFalseFromFalse"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigurationcansetparameter03.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigurationcansetparameter03"> |
| <metadata> |
| <title>domconfigurationcansetparameter03</title> |
| <creator>IBM</creator> |
| <description> |
| The canSetParameter method checks if setting a parameter to a specific value is supported. |
| The parameter entities is turned on by default. Check to see if this feature can be set |
| to false by invoking canSetParameter method. Also check that this method does not change the |
| value of parameter by checking if entities still exist in the document. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-11-06</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-canSetParameter"/> |
| </metadata> |
| <!-- required for normalizeDocument --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <var name="entity" type="Entity"/> |
| <var name="entityName" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter obj="domConfig" var="canSet" name='"entities"' value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <normalizeDocument obj="doc"/> |
| <doctype obj="doc" var="docType" interface="Document"/> |
| <entities obj="docType" var="entitiesMap" interface="DocumentType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"epsilon"'/> |
| <assertNotNull actual="entity" id="entityNotNull"/> |
| <nodeName obj="entity" var="entityName" interface="Node"/> |
| <assertEquals actual="entityName" expected='"epsilon"' id="entityName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigurationcansetparameter04.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigurationcansetparameter04"> |
| <metadata> |
| <title>domconfigurationcansetparameter04</title> |
| <creator>IBM</creator> |
| <description> |
| The parameter entities is turned on by default. Check to see if this feature can be set |
| to false by invoking canSetParameter method. Also check that this method does not change the |
| value of parameter by checking if entity references still exist in the document. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-11-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-canSetParameter"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="acronymList" type="NodeList"/> |
| <var name="acronymElem" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="first" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <var name="paramVal" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter obj="domConfig" var="canSet" name='"entities"' value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <!-- checking if it can be set false should not actually change it --> |
| <getParameter var="paramVal" obj="domConfig" name='"entities"'/> |
| <assertTrue actual="paramVal" id="stillTrue"/> |
| <!-- or change the behavior of normalize document --> |
| <normalizeDocument obj="doc"/> |
| <getElementsByTagName var="acronymList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="acronymList" index="1" interface="NodeList"/> |
| <firstChild var="first" obj="acronymElem" interface="Node"/> |
| <nodeType var="nodeType" obj="first" interface="Node"/> |
| <assertEquals actual="nodeType" expected="5" id="entityRefPreserved" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigurationcansetparameter06.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigurationcansetparameter06"> |
| <metadata> |
| <title>domconfigurationcansetparameter06</title> |
| <creator>IBM</creator> |
| <description> |
| Check that canSetParameter('element-content-whitespace', true) returns true |
| and that canSetParameter('element-content-whitespace) does not change value of |
| parameter. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-11-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-canSetParameter"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="itemList" type="NodeList"/> |
| <var name="elementBody" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetFalse" type="boolean"/> |
| <var name="paramVal" type="boolean"/> |
| <var name="hasWhitespace" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <!-- return value may be either true or false, |
| but the call should success and not actually change the value --> |
| <canSetParameter obj="domConfig" var="canSetFalse" name='"element-content-whitespace"' value="false"/> |
| <getParameter var="paramVal" obj="domConfig" name='"element-content-whitespace"'/> |
| <assertTrue actual="paramVal" id="stillTrue"/> |
| <if><isTrue value="canSetFalse"/> |
| <!-- if it can be set false, actually set it --> |
| <setParameter obj="domConfig" name='"element-content-whitespace"' value="false"/> |
| </if> |
| <canSetParameter obj="domConfig" var="canSet" name='"element-content-whitespace"' value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <if><isTrue value="canSetFalse"/> |
| <getParameter var="paramVal" obj="domConfig" name='"element-content-whitespace"'/> |
| <assertFalse actual="paramVal" id="stillFalse"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigurationgetparameter01.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigurationgetparameter01"> |
| <metadata> |
| <title>domconfigurationgetparameter01</title> |
| <creator>IBM</creator> |
| <description> |
| The method getParameter returns the value of a parameter if known. |
| Get the DOMConfiguration object of a document and verify that the default required features are set |
| to true. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-11-07</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="param" type="DOMUserData"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <getParameter obj="domConfig" var="param" name='"comments"'/> |
| <assertTrue actual="param" id="domconfigurationgetparameter01_1"/> |
| <getParameter obj="domConfig" var="param" name='"cdata-sections"'/> |
| <assertTrue actual="param" id="domconfigurationgetparameter01_2"/> |
| <getParameter obj="domConfig" var="param" name='"entities"'/> |
| <assertTrue actual="param" id="domconfigurationgetparameter01_3"/> |
| <getParameter obj="domConfig" var="param" name='"namespace-declarations"'/> |
| <assertTrue actual="param" id="domconfigurationgetparameter01_4"/> |
| <getParameter obj="domConfig" var="param" name='"infoset"'/> |
| <assertFalse actual="param" id="domconfigurationgetparameter01_5"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigurationgetparameter02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigurationgetparameter02"> |
| <metadata> |
| <title>domconfigurationgetparameter02</title> |
| <creator>IBM</creator> |
| <description> |
| The method getParameter returns the value of a parameter if known. |
| Get the DOMConfiguration object of a document and verify that a NOT_FOUND_ERR is thrown if the parameter |
| is not found. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-11-07</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="param" type="DOMUserData"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <assertDOMException id="domconfigurationgetparameter02_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <getParameter obj="domConfig" var="param" name='"not-found-param"'/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigvalidate1.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigvalidate1"> |
| <metadata> |
| <title>domconfigvalidate1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "validate" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"vAlIdate"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <!-- should still be false after failed attempt --> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setTrueNotEffective"/> |
| </else> |
| </if> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigvalidateifschema1.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigvalidateifschema1"> |
| <metadata> |
| <title>domconfigvalidateifschema1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "validate-if-schema" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate-if-schema"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"vAlIdate-if-schema"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setTrueEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <!-- should still be false after failed attempt --> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setTrueNotEffective"/> |
| </else> |
| </if> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domconfigwellformed1.xml |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domconfigwellformed1"> |
| <metadata> |
| <title>domconfigwellformed1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks behavior of "well-formed" configuration parameter.</description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-well-formed"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-getParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-setParameter"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="canSet" type="boolean"/> |
| <var name="state" type="boolean"/> |
| <var name="parameter" type="DOMString" value='"wElL-formed"'/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="defaultFalse"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <canSetParameter var="canSet" obj="domConfig" name="parameter" value="false"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertFalse actual="state" id="setFalseEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="domConfig" name="parameter" value="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| <getParameter var="state" obj="domConfig" name="parameter"/> |
| <assertTrue actual="state" id="setFalseNotEffective"/> |
| </else> |
| </if> |
| <setParameter obj="domConfig" name="parameter" value="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationgetfeature01.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationgetfeature01"> |
| <metadata> |
| <title>domimplementationgetfeature01</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke getFeature method on this DOMImplementation with the value of the feature parameter |
| as Core and version as 2.0. This should return a DOMImplmentation object that's not null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMImplementation3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplReturned" type="DOMImplementation"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <getFeature var="domImplReturned" obj="domImpl" feature='"Core"' version='"2.0"' interface="DOMImplementation"/> |
| <assertNotNull actual="domImplReturned" id="domimplementationgetfeature01" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationgetfeature02.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationgetfeature02"> |
| <metadata> |
| <title>domimplementationgetfeature02</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke getFeature method on this DOMImplementation with the value of the feature parameter |
| as Core and version as "". This should return a DOMImplementation object that's not null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMImplementation3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplReturned" type="DOMImplementation"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <getFeature var="domImplReturned" obj="domImpl" feature='"Core"' version='""' interface="DOMImplementation"/> |
| <assertNotNull actual="domImplReturned" id="domimplementationgetfeature02" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationgetfeature03.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationgetfeature03"> |
| <metadata> |
| <title>domimplementationgetfeature03</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke getFeature method on this DOMImplementation with the value of the feature parameter |
| as Core and version as null. This should return a DOMImplementation object that's not null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMImplementation3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplReturned" type="DOMImplementation"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <getFeature var="domImplReturned" obj="domImpl" feature='"Core"' version="nullVersion" interface="DOMImplementation"/> |
| <assertNotNull actual="domImplReturned" id="domimplementationgetfeature03" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationgetfeature05.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationgetfeature05"> |
| <metadata> |
| <title>domimplementationgetfeature05</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke getFeature method on this DOMImplementation with the value of the feature parameter |
| as "" and version equal to null. This should return a null DOMObject. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMImplementation3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplReturned" type="DOMImplementation"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <getFeature var="domImplReturned" obj="domImpl" feature='""' version="nullVersion" interface="DOMImplementation"/> |
| <assertNull actual="domImplReturned" id="domimplementationgetFeature05" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationgetfeature06.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationgetfeature06"> |
| <metadata> |
| <title>domimplementationgetfeature06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke getFeature method on this DOMImplementation with the value of the feature parameter |
| as "1-1" (some junk) and version equal to "*". This should return a null DOMObject. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMImplementation3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplReturned" type="DOMImplementation"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation obj="doc" var="domImpl"/> |
| <getFeature var="domImplReturned" obj="domImpl" feature='"1-1"' version='"*"' interface="DOMImplementation"/> |
| <assertNull actual="domImplReturned" id="domimplementationgetfeature06" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry01.xml |
|---|
| 0,0 → 1,34 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry01"> |
| <metadata> |
| <title>domimplementationregistry01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.newInstance() (Java) or DOMImplementationRegistry global variable |
| (ECMAScript) should not be null. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry02"> |
| <metadata> |
| <title>domimplementationregistry02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("cOrE") should return a DOMImplementation |
| where hasFeature("Core", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" features='"cOrE"' interface="DOMImplementationRegistry"/> |
| <assertNotNull actual="domImpl" id="domImplNotNull"/> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"Core"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry03.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry03"> |
| <metadata> |
| <title>domimplementationregistry03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("cOrE 3.0") should return a DOMImplementation |
| where hasFeature("Core", "3.0") returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" features='"cOrE 3.0"' interface="DOMImplementationRegistry"/> |
| <assertNotNull actual="domImpl" id="domImplNotNull"/> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"Core"' version='"3.0"'/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry04.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry04"> |
| <metadata> |
| <title>domimplementationregistry04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("+cOrE") should return a DOMImplementation |
| where hasFeature("+Core", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" features='"+cOrE"' interface="DOMImplementationRegistry"/> |
| <assertNotNull actual="domImpl" id="domImplNotNull"/> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"+Core"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry05.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry05"> |
| <metadata> |
| <title>domimplementationregistry05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("+cOrE 3.0") should return a DOMImplementation |
| where hasFeature("+Core", "3.0") returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" features='"+cOrE 3.0"' interface="DOMImplementationRegistry"/> |
| <assertNotNull actual="domImpl" id="domImplNotNull"/> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"+Core"' version='"3.0"'/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry06.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry06"> |
| <metadata> |
| <title>domimplementationregistry06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the implementation supports "XML", DOMImplementationRegistry.getDOMImplementation("xMl 3.0 cOrE") should |
| return a DOMImplementation where hasFeature("XML", "3.0"), and hasFeature("Core", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" features='"xMl 3.0 cOrE"' interface="DOMImplementationRegistry"/> |
| <assertNotNull actual="domImpl" id="domImplNotNull"/> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"XML"' version='"3.0"'/> |
| <assertTrue actual="hasFeature" id="hasXML3"/> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"Core"' version='nullVersion'/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry07.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry07"> |
| <metadata> |
| <title>domimplementationregistry07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("http://www.example.com/bogus-feature 99.0") should return |
| null. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" |
| features='"http://www.example.com/bogus-feature 99.0"' |
| interface="DOMImplementationRegistry"/> |
| <assertNull actual="domImpl" id="domImplNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry08.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry08"> |
| <metadata> |
| <title>domimplementationregistry08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("SVG") should return null or a DOMImplementation |
| where hasFeature("SVG", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="baseImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" |
| features='"SVG"' |
| interface="DOMImplementationRegistry"/> |
| <if> |
| <isNull obj="domImpl"/> |
| <implementation var="baseImpl"/> |
| <hasFeature var="hasFeature" feature='"SVG"'/> |
| <assertFalse actual="hasFeature" id="baseImplSupportsSVG"/> |
| <else> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"SVG"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry09.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry09"> |
| <metadata> |
| <title>domimplementationregistry09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("HTML") should return null or a DOMImplementation |
| where hasFeature("HTML", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="baseImpl" type="DOMImplementation"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" |
| features='"HTML"' |
| interface="DOMImplementationRegistry"/> |
| <if> |
| <isNull obj="domImpl"/> |
| <implementation var="baseImpl"/> |
| <hasFeature var="hasFeature" feature='"HTML"' version="nullVersion"/> |
| <assertFalse actual="hasFeature" id="baseImplSupportsHTML"/> |
| <else> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"HTML"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry10.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry10"> |
| <metadata> |
| <title>domimplementationregistry10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("LS") should return null or a DOMImplementation |
| where hasFeature("LS", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="baseImpl" type="DOMImplementation"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" |
| features='"LS"' |
| interface="DOMImplementationRegistry"/> |
| <if> |
| <isNull obj="domImpl"/> |
| <implementation var="baseImpl"/> |
| <hasFeature var="hasFeature" feature='"LS"' version="nullVersion"/> |
| <assertFalse actual="hasFeature" id="baseImplSupportsLS"/> |
| <else> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"LS"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry11.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry11"> |
| <metadata> |
| <title>domimplementationregistry11</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("XPath") should return null or a DOMImplementation |
| where hasFeature("XPath", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="baseImpl" type="DOMImplementation"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" |
| features='"XPath"' |
| interface="DOMImplementationRegistry"/> |
| <if> |
| <isNull obj="domImpl"/> |
| <implementation var="baseImpl"/> |
| <hasFeature var="hasFeature" feature='"XPath"' version="nullVersion"/> |
| <assertFalse actual="hasFeature" id="baseImplSupportsLS"/> |
| <else> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"XPath"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry12.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry12"> |
| <metadata> |
| <title>domimplementationregistry12</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("cOrE 3.0 xMl 3.0 eVeNts 2.0 lS") should return null |
| or a DOMImplementation that implements the specified features. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpl"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasCore" type="boolean"/> |
| <var name="hasXML" type="boolean"/> |
| <var name="hasEvents" type="boolean"/> |
| <var name="hasLS" type="boolean"/> |
| <var name="baseImpl" type="DOMImplementation"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" |
| features='"cOrE 3.0 xMl 3.0 eVeNts 2.0 lS"' |
| interface="DOMImplementationRegistry"/> |
| <if> |
| <isNull obj="domImpl"/> |
| <implementation var="baseImpl"/> |
| <hasFeature var="hasCore" obj="baseImpl" feature='"Core"' version='"3.0"'/> |
| <hasFeature var="hasXML" obj="baseImpl" feature='"XML"' version='"3.0"'/> |
| <hasFeature var="hasEvents" obj="baseImpl" feature='"Events"' version='"2.0"'/> |
| <hasFeature var="hasLS" obj="baseImpl" feature='"LS"' version='nullVersion'/> |
| <assertFalse id="baseImplFeatures"> |
| <and> |
| <isTrue value="hasCore"/> |
| <isTrue value="hasXML"/> |
| <isTrue value="hasEvents"/> |
| <isTrue value="hasLS"/> |
| </and> |
| </assertFalse> |
| <else> |
| <hasFeature var="hasCore" obj="domImpl" feature='"Core"' version='"3.0"'/> |
| <assertTrue actual="hasCore" id="hasCore"/> |
| <hasFeature var="hasXML" obj="domImpl" feature='"XML"' version='"3.0"'/> |
| <assertTrue actual="hasXML" id="hasXML"/> |
| <hasFeature var="hasEvents" obj="domImpl" feature='"Events"' version='"2.0"'/> |
| <assertTrue actual="hasEvents" id="hasEvents"/> |
| <hasFeature var="hasLS" obj="domImpl" feature='"LS"' version='nullVersion'/> |
| <assertTrue actual="hasLS" id="hasLS"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry13.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry13"> |
| <metadata> |
| <title>domimplementationregistry13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("cOrE") should return a |
| list of at least one DOMImplementation |
| where hasFeature("Core", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMImplementationList-item"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMImplementationList-length"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" features='"cOrE"' interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <item var="domImpl" obj="domImplList" index="length" interface="DOMImplementationList"/> |
| <assertNull actual="domImpl" id="item_Length_shouldBeNull"/> |
| <assertTrue id="atLeastOne"> |
| <greater actual="length" expected="0"/> |
| </assertTrue> |
| <for-each collection="domImplList" member="domImpl"> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"Core"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry14.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry14"> |
| <metadata> |
| <title>domimplementationregistry14</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("cOrE 3.0") should return |
| a list of DOMImplementation |
| where hasFeature("Core", "3.0") returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" features='"cOrE 3.0"' interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <assertTrue id="atLeastOne"> |
| <greater actual="length" expected="0"/> |
| </assertTrue> |
| <for-each collection="domImplList" member="domImpl"> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"Core"' version='"3.0"'/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry15.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry15"> |
| <metadata> |
| <title>domimplementationregistry15</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("+cOrE") should return |
| list of DOMImplementation |
| where hasFeature("+Core", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" features='"+cOrE"' interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <assertTrue id="atLeastOne"> |
| <greater actual="length" expected="0"/> |
| </assertTrue> |
| <for-each collection="domImplList" member="domImpl"> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"+Core"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry16.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry16"> |
| <metadata> |
| <title>domimplementationregistry16</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("+cOrE 3.0") should return |
| a list of DOMImplementation |
| where hasFeature("+Core", "3.0") returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" features='"+cOrE 3.0"' interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <assertTrue id="atLeastOne"> |
| <greater actual="length" expected="0"/> |
| </assertTrue> |
| <for-each collection="domImplList" member="domImpl"> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"+Core"' version='"3.0"'/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry17.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry17"> |
| <metadata> |
| <title>domimplementationregistry17</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| If the implementation supports "XML", DOMImplementationRegistry.getDOMImplementationList("xMl 3.0 cOrE") should |
| return a list of DOMImplementation where hasFeature("XML", "3.0"), and hasFeature("Core", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" features='"xMl 3.0 cOrE"' interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <assertTrue id="atLeastOne"> |
| <greater actual="length" expected="0"/> |
| </assertTrue> |
| <for-each collection="domImplList" member="domImpl"> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"XML"' version='"3.0"'/> |
| <assertTrue actual="hasFeature" id="hasXML3"/> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"Core"' version='nullVersion'/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry18.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry18"> |
| <metadata> |
| <title>domimplementationregistry18</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("http://www.example.com/bogus-feature 99.0") |
| should return a zero-length list. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" |
| features='"http://www.example.com/bogus-feature 99.0"' |
| interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <assertEquals actual="length" expected="0" ignoreCase="false" id="emptyList"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry19.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry19"> |
| <metadata> |
| <title>domimplementationregistry19</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("SVG") should return |
| zero-length list or a list of DOMImplementation |
| where hasFeature("SVG", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="baseImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" |
| features='"SVG"' |
| interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <if> |
| <equals actual="length" expected="0" ignoreCase="false"/> |
| <implementation var="baseImpl"/> |
| <hasFeature var="hasFeature" feature='"SVG"'/> |
| <assertFalse actual="hasFeature" id="baseImplSupportsSVG"/> |
| <else> |
| <for-each collection="domImplList" member="domImpl"> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"SVG"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </for-each> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry20.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry20"> |
| <metadata> |
| <title>domimplementationregistry20</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("HTML") should return |
| an empty list or a list of DOMImplementation |
| where hasFeature("HTML", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="baseImpl" type="DOMImplementation"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" |
| features='"HTML"' |
| interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <if> |
| <equals actual="length" expected="0" ignoreCase="false"/> |
| <implementation var="baseImpl"/> |
| <hasFeature var="hasFeature" feature='"HTML"' version="nullVersion"/> |
| <assertFalse actual="hasFeature" id="baseImplSupportsHTML"/> |
| <else> |
| <for-each collection="domImplList" member="domImpl"> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"HTML"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </for-each> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry21.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry21"> |
| <metadata> |
| <title>domimplementationregistry21</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("LS") should return |
| a empty list or a list of DOMImplementation |
| where hasFeature("LS", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="baseImpl" type="DOMImplementation"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" |
| features='"LS"' |
| interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <if> |
| <equals actual="length" expected="0" ignoreCase="false"/> |
| <implementation var="baseImpl"/> |
| <hasFeature var="hasFeature" feature='"LS"' version="nullVersion"/> |
| <assertFalse actual="hasFeature" id="baseImplSupportsLS"/> |
| <else> |
| <for-each collection="domImplList" member="domImpl"> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"LS"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </for-each> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry22.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry22"> |
| <metadata> |
| <title>domimplementationregistry22</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("XPath") should return |
| an empty list or a list of DOMImplementation |
| where hasFeature("XPath", null) returns true. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasFeature" type="boolean"/> |
| <var name="baseImpl" type="DOMImplementation"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" |
| features='"XPath"' |
| interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <if> |
| <equals actual="length" expected="0" ignoreCase="false"/> |
| <implementation var="baseImpl"/> |
| <hasFeature var="hasFeature" feature='"XPath"' version="nullVersion"/> |
| <assertFalse actual="hasFeature" id="baseImplSupportsLS"/> |
| <else> |
| <for-each collection="domImplList" member="domImpl"> |
| <hasFeature var="hasFeature" obj="domImpl" feature='"XPath"' version="nullVersion"/> |
| <assertTrue actual="hasFeature" id="hasCore"/> |
| </for-each> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry23.xml |
|---|
| 0,0 → 1,76 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry23"> |
| <metadata> |
| <title>domimplementationregistry23</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("cOrE 3.0 xMl 3.0 eVeNts 2.0 lS") |
| should return an empty list or a list of DOMImplementation that implements the specified features. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasCore" type="boolean"/> |
| <var name="hasXML" type="boolean"/> |
| <var name="hasEvents" type="boolean"/> |
| <var name="hasLS" type="boolean"/> |
| <var name="baseImpl" type="DOMImplementation"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" |
| features='"cOrE 3.0 xMl 3.0 eVeNts 2.0 lS"' |
| interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <if> |
| <equals actual="length" expected="0" ignoreCase="false"/> |
| <implementation var="baseImpl"/> |
| <hasFeature var="hasCore" obj="baseImpl" feature='"Core"' version='"3.0"'/> |
| <hasFeature var="hasXML" obj="baseImpl" feature='"XML"' version='"3.0"'/> |
| <hasFeature var="hasEvents" obj="baseImpl" feature='"Events"' version='"2.0"'/> |
| <hasFeature var="hasLS" obj="baseImpl" feature='"LS"' version='nullVersion'/> |
| <assertFalse id="baseImplFeatures"> |
| <and> |
| <isTrue value="hasCore"/> |
| <isTrue value="hasXML"/> |
| <isTrue value="hasEvents"/> |
| <isTrue value="hasLS"/> |
| </and> |
| </assertFalse> |
| <else> |
| <for-each collection="domImplList" member="domImpl"> |
| <hasFeature var="hasCore" obj="domImpl" feature='"Core"' version='"3.0"'/> |
| <assertTrue actual="hasCore" id="hasCore"/> |
| <hasFeature var="hasXML" obj="domImpl" feature='"XML"' version='"3.0"'/> |
| <assertTrue actual="hasXML" id="hasXML"/> |
| <hasFeature var="hasEvents" obj="domImpl" feature='"Events"' version='"2.0"'/> |
| <assertTrue actual="hasEvents" id="hasEvents"/> |
| <hasFeature var="hasLS" obj="domImpl" feature='"LS"' version='nullVersion'/> |
| <assertTrue actual="hasLS" id="hasLS"/> |
| </for-each> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry24.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry24"> |
| <metadata> |
| <title>domimplementationregistry24</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementation("") should return an implementation. |
| </description> |
| <date qualifier="created">2004-03-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom/2004JanMar/0111.html"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementation var="domImpl" obj="domImplRegistry" |
| features='""' |
| interface="DOMImplementationRegistry"/> |
| <assertNotNull actual="domImpl" id="domImplNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domimplementationregistry25.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domimplementationregistry25"> |
| <metadata> |
| <title>domimplementationregistry25</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementationRegistry.getDOMImplementationList("cOrE 3.0 xMl 3.0 eVeNts 2.0 lS") |
| should return an empty list or a list of DOMImplementation that implements the specified features. |
| </description> |
| <date qualifier="created">2004-03-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-getDOMImpls"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom/2004JanMar/0111.html"/> |
| </metadata> |
| <var name="domImplRegistry" type="DOMImplementationRegistry"/> |
| <var name="domImplList" type="DOMImplementationList"/> |
| <var name="length" type="int"/> |
| <DOMImplementationRegistry.newInstance var="domImplRegistry"/> |
| <assertNotNull actual="domImplRegistry" id="domImplRegistryNotNull"/> |
| <getDOMImplementationList var="domImplList" obj="domImplRegistry" |
| features='""' |
| interface="DOMImplementationRegistry"/> |
| <length var="length" obj="domImplList" interface="DOMImplementationList"/> |
| <assertTrue id="atLeastOne"><greater actual="length" expected="0"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domstringlistcontains01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domstringlistcontains01"> |
| <metadata> |
| <title>domstringlistcontains01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of DOMStringList.contains by searching DOMConfig parameter |
| names for "comments" and "". |
| </description> |
| <date qualifier="created">2004-01-12</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMStringList-contains"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-parameterNames"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="paramList" type="DOMStringList"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="contains" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <parameterNames obj="domConfig" var="paramList"/> |
| <contains var="contains" obj="paramList" str='"comments"' interface="DOMStringList"/> |
| <assertTrue actual="contains" id="paramsContainComments"/> |
| <contains var="contains" obj="paramList" str='""' interface="DOMStringList"/> |
| <assertFalse actual="contains" id="paramsDoesntContainEmpty"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domstringlistcontains02.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domstringlistcontains02"> |
| <metadata> |
| <title>domstringlistcontains02</title> |
| <creator>IBM</creator> |
| <description> |
| The contains method of the DOMStringList tests if a string is part of this DOMStringList. |
| Invoke the contains method on the list searching for several of the parameters recognized by the |
| DOMConfiguration object. |
| Verify that the list contains features that are required and supported by this DOMConfiguration object. |
| Verify that the contains method returns false for a string that is not contained in this DOMStringList. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMStringList-contains"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="paramList" type="DOMStringList"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="contain" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <parameterNames obj="domConfig" var="paramList"/> |
| <contains obj="paramList" var="contain" str='"comments"' interface="DOMStringList"/> |
| <assertTrue actual="contain" id="domstringlistcontains02_1"/> |
| <contains obj="paramList" var="contain" str='"cdata-sections"' interface="DOMStringList"/> |
| <assertTrue actual="contain" id="domstringlistcontains02_2"/> |
| <contains obj="paramList" var="contain" str='"entities"' interface="DOMStringList"/> |
| <assertTrue actual="contain" id="domstringlistcontains02_3"/> |
| <contains obj="paramList" var="contain" str='"error-handler"' interface="DOMStringList"/> |
| <assertTrue actual="contain" id="domstringlistcontains02_4"/> |
| <contains obj="paramList" var="contain" str='"infoset"' interface="DOMStringList"/> |
| <assertTrue actual="contain" id="domstringlistcontains02_5"/> |
| <contains obj="paramList" var="contain" str='"namespace-declarations"' interface="DOMStringList"/> |
| <assertTrue actual="contain" id="domstringlistcontains02_6"/> |
| <contains obj="paramList" var="contain" str='"element-content-whitespace"' interface="DOMStringList"/> |
| <assertTrue actual="contain" id="domstringlistcontains02_7"/> |
| <contains obj="paramList" var="contain" str='"test"' interface="DOMStringList"/> |
| <assertFalse actual="contain" id="domstringlistcontains02_8"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domstringlistgetlength01.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domstringlistgetlength01"> |
| <metadata> |
| <title>domstringlistgetlength01</title> |
| <creator>IBM</creator> |
| <description> |
| The length attribute of the DOMStringList returns the number of DOMStrings in the list. |
| The range of valid child node indices is 0 to length-1 inclusive. |
| Invoke the length on the list of parameters returned by the DOMConfiguration object. |
| Verify that the list is not null and length is not 0. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMStringList-length"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-parameterNames"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="paramList" type="DOMStringList"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="listSize" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <parameterNames obj="domConfig" var="paramList"/> |
| <assertNotNull actual="paramList" id="domstringlistgetlength01_notNull"/> |
| <length obj="paramList" var="listSize" interface="DOMStringList"/> |
| <assertNotEquals actual="listSize" expected="0" id="domstringlistgetlength01_notZero" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domstringlistitem01.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domstringlistitem01"> |
| <metadata> |
| <title>domstringlistitem01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of DOMStringList.item by accessing items 0 and length-1 and expecting |
| a string and accessing items out of range and expecting null. |
| </description> |
| <date qualifier="created">2004-01-12</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMStringList-item"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-parameterNames"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="paramList" type="DOMStringList"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="contains" type="boolean"/> |
| <var name="length" type="int"/> |
| <var name="index" type="int"/> |
| <var name="parameter" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <parameterNames obj="domConfig" var="paramList"/> |
| <length var="length" obj="paramList" interface="DOMStringList"/> |
| <item var="parameter" obj="paramList" index="0" interface="DOMStringList"/> |
| <assertNotNull actual="parameter" id="item0NotNull"/> |
| <item var="parameter" obj="paramList" index="length" interface="DOMStringList"/> |
| <assertNull actual="parameter" id="itemLengthNull"/> |
| <decrement var="length" value="1"/> |
| <item var="parameter" obj="paramList" index="length" interface="DOMStringList"/> |
| <assertNotNull actual="parameter" id="itemLengthMinus1NotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/domstringlistitem02.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="domstringlistitem02"> |
| <metadata> |
| <title>domstringlistitem02</title> |
| <creator>IBM</creator> |
| <description> |
| The item method of the DOMStringList Returns the indexth item in the collection. |
| If index is greater than or equal to the number of DOMStrings in the list, this returns null. |
| Invoke the first item on the list of parameters returned by the DOMConfiguration object and |
| make sure it is not null. Then invoke the 100th item and verify that null is returned. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMStringList-item"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="paramList" type="DOMStringList"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="listSize" type="int"/> |
| <var name="retStr" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <parameterNames obj="domConfig" var="paramList"/> |
| <item obj="paramList" var="retStr" index="0" interface="DOMStringList"/> |
| <assertNotNull actual="retStr" id="domstringlistitem02_notNull"/> |
| <item obj="paramList" var="retStr" index="100" interface="DOMStringList"/> |
| <assertNull actual="retStr" id="domstringlistitem02_null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementcontentwhitespace01.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementcontentwhitespace01"> |
| <metadata> |
| <title>elementcontentwhitespace01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with element-content-whitespace set to true, check that |
| whitespace in element content is preserved. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-element-content-whitespace"/> |
| </metadata> |
| <!-- required for normalizationDocument --> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="body" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="childType" type="int"/> |
| <var name="text" type="Text"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"element-content-whitespace"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName |
| var="bodyList" |
| obj="doc" |
| tagname='"body"' |
| interface="Document"/> |
| <item var="body" obj="bodyList" interface="NodeList" index="0"/> |
| <firstChild var="child" obj="body" interface="Node"/> |
| <nodeType var="childType" obj="child"/> |
| <!-- if first child was an element |
| whitespace has been eliminated, add some back --> |
| <if><equals actual="childType" expected="1" ignoreCase="false"/> |
| <createTextNode var="text" obj="doc" data='" "'/> |
| <insertBefore var="child" obj="body" newChild="text" refChild="child"/> |
| </if> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="bodyList" |
| obj="doc" |
| tagname='"body"' |
| interface="Document"/> |
| <item var="body" obj="bodyList" interface="NodeList" index="0"/> |
| <firstChild var="child" obj="body" interface="Node"/> |
| <assertNotNull actual="child" id="firstChildNotNull"/> |
| <!-- this should be a Text node --> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"#text"' ignoreCase="false" id="firstChild"/> |
| <nextSibling var="child" obj="child" interface="Node"/> |
| <assertNotNull actual="child" id="secondChildNotNull"/> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"p"' ignoreCase="false" id="secondChild"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementcontentwhitespace02.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementcontentwhitespace02"> |
| <metadata> |
| <title>elementcontentwhitespace02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with element-content-whitespace set to false and validation set to true, check that |
| whitespace in element content is eliminated. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-element-content-whitespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="body" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"element-content-whitespace"' value="false"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSet"/> |
| </and> |
| <setParameter obj="domConfig" name='"element-content-whitespace"' value="false"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="bodyList" |
| obj="doc" |
| tagname='"body"' |
| interface="Document"/> |
| <item var="body" obj="bodyList" interface="NodeList" index="0"/> |
| <firstChild var="child" obj="body" interface="Node"/> |
| <assertNotNull actual="child" id="firstChildNotNull"/> |
| <!-- if normalization was successful this should be a "p" element --> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"p"' ignoreCase="false" id="firstChild"/> |
| <nextSibling var="child" obj="child" interface="Node"/> |
| <assertNull actual="child" id="secondChild"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementcontentwhitespace03.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementcontentwhitespace03"> |
| <metadata> |
| <title>elementcontentwhitespace03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document using Node.normalize with element-content-whitespace set to false and validation set to true, check that |
| whitespace in element content is preserved. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-element-content-whitespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="body" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="text" type="Text"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <!-- if we discarded whitespace on parse, add some back --> |
| <if><implementationAttribute name="ignoringElementContentWhitespace" value="true"/> |
| <getElementsByTagName |
| var="bodyList" |
| obj="doc" |
| tagname='"body"' |
| interface="Document"/> |
| <item var="body" obj="bodyList" interface="NodeList" index="0"/> |
| <firstChild var="child" obj="body" interface="Node"/> |
| <createTextNode var="text" obj="doc" data='" "'/> |
| <insertBefore var="child" obj="body" newChild="text" refChild="child"/> |
| </if> |
| <canSetParameter var="canSet" obj="domConfig" name='"element-content-whitespace"' value="false"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"element-content-whitespace"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalize obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="bodyList" |
| obj="doc" |
| tagname='"body"' |
| interface="Document"/> |
| <item var="body" obj="bodyList" interface="NodeList" index="0"/> |
| <firstChild var="child" obj="body" interface="Node"/> |
| <assertNotNull actual="child" id="firstChildNotNull"/> |
| <!-- this should be a Text node --> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"#text"' ignoreCase="false" id="firstChild"/> |
| <nextSibling var="child" obj="child" interface="Node"/> |
| <assertNotNull actual="child" id="secondChildNotNull"/> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"p"' ignoreCase="false" id="secondChild"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementgetschematypeinfo01.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementgetschematypeinfo01"> |
| <metadata> |
| <title>elementgetschematypeinfo01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call getSchemaTypeInfo on title attribute for the first "em" element from DTD validated document. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Element-schemaTypeInfo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeNamespace"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="typeNS" type="DOMString"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertNull actual="typeName" id="nameIsNull"/> |
| <typeNamespace var="typeNS" obj="typeInfo"/> |
| <assertNull actual="typeNS" id="nsIsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementgetschematypeinfo02.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementgetschematypeinfo02"> |
| <metadata> |
| <title>elementgetschematypeinfo02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call getSchemaTypeInfo on title attribute for the first "em" element from schema-validated document. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Element-schemaTypeInfo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeNamespace"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="typeNS" type="DOMString"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"emType"' ignoreCase="false" id="nameIsEmType"/> |
| <typeNamespace var="typeNS" obj="typeInfo"/> |
| <assertEquals actual="typeNS" expected='"http://www.w3.org/1999/xhtml"' ignoreCase="false" id="nsIsXML"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementgetschematypeinfo03.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementgetschematypeinfo03"> |
| <metadata> |
| <title>elementgetschematypeinfo03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Element.schemaTypeInfo should return null if not validating or schema validating. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Element-schemaTypeInfo"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeNamespace"/> |
| </metadata> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="typeNS" type="DOMString"/> |
| <load var="doc" href="hc_nodtdstaff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertNull actual="typeName" id="typeName"/> |
| <typeNamespace var="typeNS" obj="typeInfo"/> |
| <assertNull actual="typeNS" id="typeNS"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementgetschematypeinfo04.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementgetschematypeinfo04"> |
| <metadata> |
| <title>elementgetschematypeinfo04</title> |
| <creator>IBM</creator> |
| <description> |
| The getSchemaTypeInfo method retrieves the type information associated with this element. |
| Load a valid document with an XML Schema. |
| Invoke getSchemaTypeInfo method on an element having [type definition] property. Expose {name} and {target namespace} |
| properties of the [type definition] property. Verity that the typeName and typeNamespace of the code element's |
| schemaTypeInfo are correct. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-28</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Element-schemaTypeInfo"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="codeElem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="typeNamespace" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="docElemNodeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"code"' interface="Document"/> |
| <item var="codeElem" obj="elemList" index="1" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="codeElem" interface="Element"/> |
| <typeName var="typeName" obj="elemTypeInfo"/> |
| <typeNamespace var="typeNamespace" obj="elemTypeInfo"/> |
| <assertEquals expected='"code"' actual="typeName" id="elementgetschematypeinfo04_typeName" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/1999/xhtml"' actual="typeNamespace" id="elementgetschematypeinfo04_typeNamespace" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementgetschematypeinfo05.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementgetschematypeinfo05"> |
| <metadata> |
| <title>elementgetschematypeinfo05</title> |
| <creator>IBM</creator> |
| <description> |
| The getSchemaTypeInfo method retrieves the type information associated with this element. |
| Load a valid document with an XML Schema. |
| Invoke getSchemaTypeInfo method on an element having [type definition] property. Expose {name} and {target namespace} |
| properties of the [type definition] property. Verity that the typeName and typeNamespace of the acronym element's |
| schemaTypeInfo are correct. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-28</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Element-schemaTypeInfo"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="acElem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="typeNamespace" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="docElemNodeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"span"' interface="Document"/> |
| <item var="acElem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="acElem" interface="Element"/> |
| <typeName var="typeName" obj="elemTypeInfo"/> |
| <typeNamespace var="typeNamespace" obj="elemTypeInfo"/> |
| <assertEquals expected='"string"' actual="typeName" id="typeNameString" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/2001/XMLSchema"' actual="typeNamespace" id="typeNsXSD" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementgetschematypeinfo06.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementgetschematypeinfo06"> |
| <metadata> |
| <title>elementgetschematypeinfo06</title> |
| <creator>IBM</creator> |
| <description> |
| The getSchemaTypeInfo method retrieves the type information associated with this element. |
| Load a valid document with an XML Schema. |
| Invoke getSchemaTypeInfo method on an element having [type definition] property. Expose {name} and {target namespace} |
| properties of the [type definition] property. Verity that the typeName and typeNamespace of the strong element's |
| schemaTypeInfo are correct. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-28</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Element-schemaTypeInfo"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="strongElem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="typeNamespace" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="docElemNodeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="strongElem" obj="elemList" index="1" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="strongElem" interface="Element"/> |
| <typeName var="typeName" obj="elemTypeInfo"/> |
| <typeNamespace var="typeNamespace" obj="elemTypeInfo"/> |
| <assertEquals expected='"strongType"' actual="typeName" id="elementgetschematypeinfo06_typeName" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/1999/xhtml"' actual="typeNamespace" id="elementgetschematypeinfo06_typeNamespace" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementgetschematypeinfo07.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementgetschematypeinfo07"> |
| <metadata> |
| <title>elementgetschematypeinfo07</title> |
| <creator>IBM</creator> |
| <description> |
| The getSchemaTypeInfo method retrieves the type information associated with this element. |
| Load a valid document with an XML Schema. |
| Invoke getSchemaTypeInfo method on an element having [type definition] property. Expose {name} and {target namespace} |
| properties of the [type definition] property. Verity that the typeName and typeNamespace of the name element's |
| schemaTypeInfo are correct. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-28</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Element-schemaTypeInfo"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="supElem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="typeNamespace" type="DOMString"/> |
| <var name="docElemNodeName" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"sup"' interface="Document"/> |
| <item var="supElem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="supElem" interface="Element"/> |
| <typeName var="typeName" obj="elemTypeInfo"/> |
| <typeNamespace var="typeNamespace" obj="elemTypeInfo"/> |
| <assertEquals expected='"sup"' actual="typeName" id="elementgetschematypeinfo07_typeName" ignoreCase="false"/> |
| <assertEquals expected='"http://www.w3.org/1999/xhtml"' actual="typeNamespace" id="elementgetschematypeinfo07_typeNamespace" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattribute01.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattribute01"> |
| <metadata> |
| <title>elementsetidattribute01</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttribute on the third acronym element's class attribute. Verify by calling isID |
| on the class attribute and getElementById on document. Invoke setIdAttribute again to reset. |
| Calling isID should return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <setIdAttribute obj="acronymElem" name='"class"' isId="true"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsIdTrue01"/> |
| <getElementById obj="doc" var="elem" elementId='"No"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributeGetElementById01" ignoreCase="false"/> |
| <setIdAttribute obj="acronymElem" name='"class"' isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributeIsIdFalse01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattribute03.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattribute03"> |
| <metadata> |
| <title>elementsetidattribute03</title> |
| <creator>IBM</creator> |
| <description> |
| First use setAttribute to change the class attribute of the third acronym element. Invoke setIdAttribute |
| on the newly set attribute. Verify by calling isID on the new attribute and getElementById on document. |
| Invoke setIdAttribute again to reset. Calling isID should return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <setAttribute obj="acronymElem" name= '"class"' value='"Maybe"'/> |
| <setIdAttribute obj="acronymElem" name='"class"' isId="true"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsIdTrue03"/> |
| <getElementById obj="doc" var="elem" elementId='"Maybe"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributeGetElementById03" ignoreCase="false"/> |
| <setIdAttribute obj="acronymElem" name='"class"' isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributeIsIdFalse03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattribute04.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattribute04"> |
| <metadata> |
| <title>elementsetidattribute04</title> |
| <creator>IBM</creator> |
| <description> |
| First use setAttribute to create a new attribute on the third strong element. Invoke setIdAttribute |
| on the new attribute. Verify by calling isID on the new attribute and getElementById on document. |
| Invoke setIdAttribute again to reset. Calling isID should return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="nameElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="nameElem" obj="elemList" index="2" interface="NodeList"/> |
| <setAttribute obj="nameElem" name= '"hasMiddleName"' value='"Antoine"'/> |
| <setIdAttribute obj="nameElem" name='"hasMiddleName"' isId="true"/> |
| <attributes var="attributesMap" obj="nameElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"hasMiddleName"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsIdTrue03"/> |
| <getElementById obj="doc" var="elem" elementId='"Antoine"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"strong"' id="elementsetidattributeGetElementById03" ignoreCase="false"/> |
| <setIdAttribute obj="nameElem" name='"hasMiddleName"' isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributeIsIdFalse03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattribute05.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattribute05"> |
| <metadata> |
| <title>elementsetidattribute05</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttribute on the third strong element with a non-existing attribute name. Verify that |
| NOT_FOUND_ERR is raised. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="nameElem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="nameElem" obj="elemList" index="2" interface="NodeList"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <setIdAttribute obj="nameElem" name='"hasMiddleName"' isId="true"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattribute06.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattribute06"> |
| <metadata> |
| <title>elementsetidattribute06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttribute on the third strong element with an attribute name of the acronym element. |
| Verify that NOT_FOUND_ERR is raised. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="nameElem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="nameElem" obj="elemList" index="2" interface="NodeList"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <setIdAttribute obj="nameElem" name='"class"' isId="true"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattribute07.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattribute07"> |
| <metadata> |
| <title>elementsetidattribute07</title> |
| <creator>IBM</creator> |
| <description> |
| First use setAttribute to create two new attribute of the second and third strong element with different values. |
| Invoke setIdAttribute on the new attributes. Verify by calling isID on the new attributes and getElementById |
| with two different values on document. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="nameElem1" type="Element"/> |
| <var name="nameElem2" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="nameElem1" obj="elemList" index="2" interface="NodeList"/> |
| <item var="nameElem2" obj="elemList" index="3" interface="NodeList"/> |
| <setAttribute obj="nameElem1" name= '"hasMiddleName"' value='"Antoine"'/> |
| <setIdAttribute obj="nameElem1" name='"hasMiddleName"' isId="true"/> |
| <setAttribute obj="nameElem2" name= '"hasMiddleName"' value='"Neeya"'/> |
| <setIdAttribute obj="nameElem2" name='"hasMiddleName"' isId="true"/> |
| <attributes var="attributesMap" obj="nameElem1"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"hasMiddleName"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsId1True07"/> |
| <attributes var="attributesMap" obj="nameElem2"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"hasMiddleName"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsId2True07"/> |
| <getElementById obj="doc" var="elem" elementId='"Antoine"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"strong"' id="elementsetidattribute1GetElementById07" ignoreCase="false"/> |
| <getElementById obj="doc" var="elem" elementId='"Neeya"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"strong"' id="elementsetidattribute2GetElementById07" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattribute08.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattribute08"> |
| <metadata> |
| <title>elementsetidattribute08</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttribute class attribute on the second, third, and the fifth acronym element. |
| Verify by calling isID on the attributes and getElementById with the unique value "No" on document. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem1" type="Element"/> |
| <var name="acronymElem2" type="Element"/> |
| <var name="acronymElem3" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem1" obj="elemList" index="1" interface="NodeList"/> |
| <item var="acronymElem2" obj="elemList" index="2" interface="NodeList"/> |
| <item var="acronymElem3" obj="elemList" index="4" interface="NodeList"/> |
| <setIdAttribute obj="acronymElem1" name='"class"' isId="true"/> |
| <setIdAttribute obj="acronymElem2" name='"class"' isId="true"/> |
| <setIdAttribute obj="acronymElem3" name='"class"' isId="true"/> |
| <attributes var="attributesMap" obj="acronymElem1"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsId1True08"/> |
| <attributes var="attributesMap" obj="acronymElem2"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsId2True08"/> |
| <attributes var="attributesMap" obj="acronymElem3"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsId3True08"/> |
| <getElementById obj="doc" var="elem" elementId='"No"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributeGetElementById08" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattribute09.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattribute09"> |
| <metadata> |
| <title>elementsetidattribute09</title> |
| <creator>IBM</creator> |
| <description> |
| First use setAttribute to create two new attributes on the second strong element and sup element. |
| Invoke setIdAttribute on the new attributes. Verify by calling isID on the new attributes and getElementById |
| with two different values on document. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList1" type="NodeList"/> |
| <var name="elemList2" type="NodeList"/> |
| <var name="nameElem" type="Element"/> |
| <var name="salaryElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList1" obj="doc" tagname='"strong"' interface="Document"/> |
| <getElementsByTagName var="elemList2" obj="doc" tagname='"sup"' interface="Document"/> |
| <item var="nameElem" obj="elemList1" index="2" interface="NodeList"/> |
| <item var="salaryElem" obj="elemList2" index="2" interface="NodeList"/> |
| <setAttribute obj="nameElem" name= '"hasMiddleName"' value='"Antoine"'/> |
| <setAttribute obj="salaryElem" name= '"annual"' value='"2002"'/> |
| <setIdAttribute obj="nameElem" name='"hasMiddleName"' isId="true"/> |
| <setIdAttribute obj="salaryElem" name='"annual"' isId="true"/> |
| <attributes var="attributesMap" obj="nameElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"hasMiddleName"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsId1True09"/> |
| <attributes var="attributesMap" obj="salaryElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"annual"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsId2True09"/> |
| <getElementById obj="doc" var="elem" elementId='"Antoine"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"strong"' id="elementsetidattribute1GetElementById09" ignoreCase="false"/> |
| <getElementById obj="doc" var="elem" elementId='"2002"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"sup"' id="elementsetidattribute2GetElementById09" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattribute10.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattribute10"> |
| <metadata> |
| <title>elementsetidattribute10</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttribute on the third acronym element's class attribute consecutively with different |
| isId values. Verify by calling isId on the attribute. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <setIdAttribute obj="acronymElem" name='"class"' isId="true"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsId1True10"/> |
| <setIdAttribute obj="acronymElem" name='"class"' isId="true"/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsId2True10"/> |
| <setIdAttribute obj="acronymElem" name='"class"' isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributeIsIdFalse10"/> |
| <getElementById obj="doc" var="elem" elementId='"No"'/> |
| <assertNull actual="elem" id="elementsetidattributeGetElementByIdNull10"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattribute11.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattribute11"> |
| <metadata> |
| <title>elementsetidattribute11</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttribute on the 4th acronym element's class attribute which contains |
| an entity reference. Verify by calling isID on the class attribute and getElementById |
| on document. Invoke setIdAttribute again to reset. Calling isID should return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="3" interface="NodeList"/> |
| <setIdAttribute obj="acronymElem" name='"class"' isId="true"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributeIsIdTrue01"/> |
| <getElementById obj="doc" var="elem" elementId='"Yα"'/> |
| <assertNotNull actual="elem" id="elemByIDNotNull"/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributeGetElementById11" ignoreCase="false"/> |
| <setIdAttribute obj="acronymElem" name='"class"' isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributeIsIdFalse11"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributenode01.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributenode01"> |
| <metadata> |
| <title>elementsetidattributenode01</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNode on the 3rd p element using the title attribute as a parameter . Verify by calling |
| isID on the attribute node and getElementById on document node. Call setIdAttributeNode again with isId=false |
| to reset. Invoke isId on the attribute node should return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="employeeElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="employeeElem" obj="elemList" index="2" interface="NodeList"/> |
| <attributes var="attributesMap" obj="employeeElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:dmstc"'/> |
| <setIdAttributeNode obj="employeeElem" idAttr="attr" isId="true"/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributenodeIsIdTrue01"/> |
| <getElementById obj="doc" var="elem" elementId='"http://www.netzero.com"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"p"' id="elementsetidattributenodeGetElementById01" ignoreCase="false"/> |
| <setIdAttributeNode obj="elem" idAttr="attr" isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributenodeIsIdFalse01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributenode02.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributenode02"> |
| <metadata> |
| <title>elementsetidattributenode02</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNode on the 3rd acronym element using the class attribute as a parameter . Verify by calling |
| isID on the attribute node and getElementById on document node. Call setIdAttributeNode again with isId=false |
| to reset. Invoke isId on the attribute node should return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <setIdAttributeNode obj="acronymElem" idAttr="attr" isId="true"/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributenodeIsIdTrue02"/> |
| <getElementById obj="doc" var="elem" elementId='"No"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributenodeGetElementById02" ignoreCase="false"/> |
| <setIdAttributeNode obj="elem" idAttr="attr" isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributenodeIsIdFalse02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributenode03.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributenode03"> |
| <metadata> |
| <title>elementsetidattributenode03</title> |
| <creator>IBM</creator> |
| <description> |
| Create a new attribute node on the second strong element. Invoke setIdAttributeNode on a newly created |
| attribute node. Verify by calling isID on the attribute node and getElementById on document node. |
| Call setIdAttributeNode again with isId=false to reset. Invoke isId on the attribute node should return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="nameElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="nameElem" obj="elemList" index="1" interface="NodeList"/> |
| <setAttribute obj="nameElem" name='"title"' value='"Karen"'/> |
| <attributes var="attributesMap" obj="nameElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"title"'/> |
| <setIdAttributeNode obj="nameElem" idAttr="attr" isId="true"/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributenodeIsIdTrue03"/> |
| <getElementById obj="doc" var="elem" elementId='"Karen"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"strong"' id="elementsetidattributenodeGetElementById03" ignoreCase="false"/> |
| <setIdAttributeNode obj="elem" idAttr="attr" isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributenodeIsIdFalse03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributenode04.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributenode04"> |
| <metadata> |
| <title>elementsetidattributenode04</title> |
| <creator>IBM</creator> |
| <description> |
| Create a new namespace attribute on the second strong element. Invoke setIdAttributeNode on a newly created |
| attribute node. Verify by calling isID on the attribute node and getElementById on document node. |
| Call setIdAttributeNode again with isId=false to reset. Invoke isId on the attribute node should return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="nameElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="nameElem" obj="elemList" index="1" interface="NodeList"/> |
| <setAttributeNS obj="nameElem" namespaceURI='"http://www.w3.org/2000/xmlns/"' qualifiedName='"xmlns:middle"' value='"http://www.example.com/middle"'/> |
| <attributes var="attributesMap" obj="nameElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:middle"'/> |
| <setIdAttributeNode obj="nameElem" idAttr="attr" isId="true"/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributenodeIsIdTrue04"/> |
| <getElementById obj="doc" var="elem" elementId='"http://www.example.com/middle"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"strong"' id="elementsetidattributenodeGetElementById04" ignoreCase="false"/> |
| <setIdAttributeNode obj="elem" idAttr="attr" isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributenodeIsIdFalse04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributenode05.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributenode05"> |
| <metadata> |
| <title>elementsetidattributenode05</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNode on the third strong element but with the class attribute of the acronym |
| element as a parameter. Verify that NOT_FOUND_ERR is raised. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList1" type="NodeList"/> |
| <var name="elemList2" type="NodeList"/> |
| <var name="nameElem" type="Element"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList1" obj="doc" tagname='"strong"' interface="Document"/> |
| <getElementsByTagName var="elemList2" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="nameElem" obj="elemList1" index="1" interface="NodeList"/> |
| <item var="acronymElem" obj="elemList2" index="1" interface="NodeList"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <setIdAttributeNode obj="nameElem" idAttr="attr" isId="true"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributenode06.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributenode06"> |
| <metadata> |
| <title>elementsetidattributenode06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNode on the third strong element but with the title attribute of the acronym |
| element as a parameter. Verify that NOT_FOUND_ERR is raised. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList1" type="NodeList"/> |
| <var name="elemList2" type="NodeList"/> |
| <var name="nameElem" type="Element"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="nameElement" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList1" obj="doc" tagname='"strong"' interface="Document"/> |
| <getElementsByTagName var="elemList2" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="nameElem" obj="elemList1" index="1" interface="NodeList"/> |
| <item var="acronymElem" obj="elemList2" index="1" interface="NodeList"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xsi:noNamespaceSchemaLocation"'/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <setIdAttributeNode obj="nameElem" idAttr="attr" isId="true"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributenode07.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributenode07"> |
| <metadata> |
| <title>elementsetidattributenode07</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNode on the 2nd and 3rd acronym element using the class attribute as a parameter . Verify by calling |
| isID on the attribute node and getElementById on document node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList1" type="NodeList"/> |
| <var name="elemList2" type="NodeList"/> |
| <var name="acronymElem1" type="Element"/> |
| <var name="acronymElem2" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList1" obj="doc" tagname='"acronym"' interface="Document"/> |
| <getElementsByTagName var="elemList2" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem1" obj="elemList1" index="1" interface="NodeList"/> |
| <item var="acronymElem2" obj="elemList2" index="2" interface="NodeList"/> |
| <attributes var="attributesMap" obj="acronymElem1"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <setIdAttributeNode obj="acronymElem1" idAttr="attr" isId="true"/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributenodeIsId1True07"/> |
| <attributes var="attributesMap" obj="acronymElem2"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <setIdAttributeNode obj="acronymElem2" idAttr="attr" isId="true"/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributenodeIsId2True07"/> |
| <getElementById obj="doc" var="elem" elementId='"No"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributenode1GetElementById07" ignoreCase="false"/> |
| <getElementById obj="doc" var="elem" elementId='"Yes"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributenode2GetElementById07" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributenode08.xml |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributenode08"> |
| <metadata> |
| <title>elementsetidattributenode08</title> |
| <creator>IBM</creator> |
| <description> |
| This method declares the attribute specified by node to be of type ID. If the value of the specified attribute |
| is unique then this element node can later be retrieved using getElementById on Document. Note, however, |
| that this simply affects this node and does not change any grammar that may be in use. |
| Invoke setIdAttributeNode on the 2nd acronym element and 3rd p element using the title and xmlns:dmstc attributes respectively |
| as parameters . Verify by calling isID on the attribute node and getElementById on document node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList1" type="NodeList"/> |
| <var name="elemList2" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="pElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList1" obj="doc" localName='"acronym"' namespaceURI='"*"' interface="Document"/> |
| <getElementsByTagNameNS var="elemList2" obj="doc" localName='"p"' namespaceURI='"*"' interface="Document"/> |
| <item var="acronymElem" obj="elemList1" index="1" interface="NodeList"/> |
| <item var="pElem" obj="elemList2" index="2" interface="NodeList"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"title"'/> |
| <setIdAttributeNode obj="acronymElem" idAttr="attr" isId="true"/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributenodeIsId1True08"/> |
| <attributes var="attributesMap" obj="pElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:dmstc"'/> |
| <setIdAttributeNode obj="pElem" idAttr="attr" isId="true"/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributenodeIsId2True08"/> |
| <getElementById obj="doc" var="elem" elementId='"Yes"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributenode1GetElementById08" ignoreCase="false"/> |
| <getElementById obj="doc" var="elem" elementId='"http://www.netzero.com"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"p"' id="elementsetidattributenode2GetElementById08" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributenode09.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributenode09"> |
| <metadata> |
| <title>elementsetidattributenode09</title> |
| <creator>IBM</creator> |
| <description> |
| This method declares the attribute specified by node to be of type ID. If the value of the specified attribute |
| is unique then this element node can later be retrieved using getElementById on Document. Note, however, |
| that this simply affects this node and does not change any grammar that may be in use. |
| Invoke setIdAttributeNode with the xmlns attribute of ent4. Verify that NO_MODIFICATION_ALLOWED_ERR is raised. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="varElem" type="Element"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <setParameter obj="domConfig" name='"entities"' value="true" interface="DOMConfiguration"/> |
| <normalizeDocument obj="doc" interface="Document"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"var"' namespaceURI='"*"' interface="Document"/> |
| <item interface="NodeList" obj="elemList" var="varElem" index="2"/> |
| <firstChild interface="Node" var="entRef" obj="varElem"/> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <attributes var="attributesMap" obj="entElement"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setIdAttributeNode obj="entElement" idAttr="attr" isId="true"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributenode10.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributenode10"> |
| <metadata> |
| <title>elementsetidattributenode10</title> |
| <creator>IBM</creator> |
| <description> |
| This method declares the attribute specified by node to be of type ID. If the value of the specified attribute |
| is unique then this element node can later be retrieved using getElementById on Document. Note, however, |
| that this simply affects this node and does not change any grammar that may be in use. |
| Invoke setIdAttributeNode on the 4th acronym element using the class attribute (containing entity reference) |
| as a parameter . Verify by calling isId on the attribute node and getElementById on document node. |
| Reset by invoking setIdAttributeNode with isId=false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-27</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"acronym"' namespaceURI='"*"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="3" interface="NodeList"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <setIdAttributeNode obj="acronymElem" idAttr="attr" isId="true"/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributenodeIsIdTrue10"/> |
| <getElementById obj="doc" var="elem" elementId='"Yα"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributenodeGetElementById10" ignoreCase="false"/> |
| <setIdAttributeNode obj="acronymElem" idAttr="attr" isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributenodeIsIdFalse10"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens01.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens01"> |
| <metadata> |
| <title>elementsetidattributens01</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNS on an existing namespace attribute with a namespace URI and a qualified name. Verify by calling |
| isId on the attribute node and getElementById on document node. Call setIdAttributeNS with isId=false to reset. |
| isId should now return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="employeeElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="employeeElem" obj="elemList" index="2" interface="NodeList"/> |
| <setIdAttributeNS obj="employeeElem" localName='"dmstc"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="true"/> |
| <attributes var="attributesMap" obj="employeeElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:dmstc"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsIdTrue01"/> |
| <getElementById obj="doc" var="elem" elementId='"http://www.netzero.com"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"p"' id="elementsetidattributensGetElementById01" ignoreCase="false"/> |
| <setIdAttributeNS obj="employeeElem" localName='"dmstc"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributensIsIdFalse01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens02.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens02"> |
| <metadata> |
| <title>elementsetidattributens02</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNS on an existing attribute with a namespace URI and a qualified name. Verify by calling |
| isID on the attribute node and getElementById on document node. Assume the grammar has not defined any |
| element of typeID. Call setIdAttributeNS with isId=false to reset. Method isId should now return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="addressElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="xsiNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema-instance"'/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"acronym"' namespaceURI='"*"' interface="Document"/> |
| <item var="addressElem" obj="elemList" index="2" interface="NodeList"/> |
| <setIdAttributeNS obj="addressElem" localName='"noNamespaceSchemaLocation"' namespaceURI='xsiNS' isId="true"/> |
| <attributes var="attributesMap" obj="addressElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xsi:noNamespaceSchemaLocation"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsIdTrue02"/> |
| <getElementById obj="doc" var="elem" elementId='"Yes"'/> |
| <assertNotNull actual="elem" id="getElementByIDNotNull"/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributensGetElementById01" ignoreCase="false"/> |
| <setIdAttributeNS obj="addressElem" localName='"noNamespaceSchemaLocation"' namespaceURI='xsiNS' isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributensIsIdFalse02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens03.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens03"> |
| <metadata> |
| <title>elementsetidattributens03</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNS on a newly added namespace attribute on the first em element. Verify by calling |
| isID on the attribute node and getElementById on document node. Call setIdAttributeNS with isId=false to reset. |
| Method isId should now return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="employeeIdElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="employeeIdElem" obj="elemList" index="0" interface="NodeList"/> |
| <setAttributeNS obj="employeeIdElem" qualifiedName='"xmlns:newAttr"' namespaceURI='"http://www.w3.org/2000/xmlns/"' value='"newValue"'/> |
| <setIdAttributeNS obj="employeeIdElem" localName='"newAttr"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="true"/> |
| <attributes var="attributesMap" obj="employeeIdElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:newAttr"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsIdTrue03"/> |
| <getElementById obj="doc" var="elem" elementId='"newValue"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"em"' id="elementsetidattributensGetElementById03" ignoreCase="false"/> |
| <setIdAttributeNS obj="employeeIdElem" localName='"newAttr"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributensIsIdFalse03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens04.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens04"> |
| <metadata> |
| <title>elementsetidattributens04</title> |
| <creator>IBM</creator> |
| <description> |
| The method setIdAttributeNS declares the attribute specified by local name and namespace URI to be of type ID. |
| If the value of the specified attribute is unique then this element node can later be retrieved using getElementById on Document. |
| Note, however, that this simply affects this node and does not change any grammar that may be in use. |
| Invoke setIdAttributeNS on newly added attribute on the third strong element. Verify by calling |
| isID on the attribute node and getElementById on document node. |
| Call setIdAttributeNS with isId=false to reset. Method isId should now return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="strongElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"strong"' namespaceURI='"*"' interface="Document"/> |
| <item var="strongElem" obj="elemList" index="2" interface="NodeList"/> |
| <setAttributeNS obj="strongElem" qualifiedName='"dmstc:newAttr"' namespaceURI='"http://www.netzero.com"' value='"newValue"'/> |
| <setIdAttributeNS obj="strongElem" localName='"newAttr"' namespaceURI='"http://www.netzero.com"' isId="true"/> |
| <attributes var="attributesMap" obj="strongElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"dmstc:newAttr"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsIdTrue04"/> |
| <getElementById obj="doc" var="elem" elementId='"newValue"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"strong"' id="elementsetidattributensGetElementById04" ignoreCase="false"/> |
| <setIdAttributeNS obj="strongElem" localName='"newAttr"' namespaceURI='"http://www.netzero.com"' isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributensIsIdFalse04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens05.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens05"> |
| <metadata> |
| <title>elementsetidattributens05</title> |
| <creator>IBM</creator> |
| <description> |
| The method setIdAttributeNS declares the attribute specified by local name and namespace URI to be of type ID. |
| If the value of the specified attribute is unique then this element node can later be retrieved using getElementById on Document. |
| Note, however, that this simply affects this node and does not change any grammar that may be in use. |
| Invoke setIdAttributeNS on a changed attribute of the third acronym element. Verify by calling |
| isID on the attribute node and getElementById on document node. |
| Call setIdAttributeNS with isId=false to reset. Method isId should now return false. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"acronym"' namespaceURI='"*"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <setAttributeNS obj="acronymElem" qualifiedName='"title"' namespaceURI='"*"' value='"newValue"'/> |
| <setIdAttributeNS obj="acronymElem" localName='"title"' namespaceURI='"*"' isId="true"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"title"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsIdTrue05"/> |
| <getElementById obj="doc" var="elem" elementId='"newValue"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributensGetElementById05" ignoreCase="false"/> |
| <setIdAttributeNS obj="acronymElem" localName='"title"' namespaceURI='"*"' isId="false"/> |
| <isId var="id" obj="attr"/> |
| <assertFalse actual="id" id="elementsetidattributensIsIdFalse05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens06.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens06"> |
| <metadata> |
| <title>elementsetidattributens06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNS on the third strong element with a non-existing attribute name. Verify that |
| NOT_FOUND_ERR is raised. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="nameElem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="nameElem" obj="elemList" index="2" interface="NodeList"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <setIdAttributeNS obj="nameElem" localName='"hasMiddleName"' namespaceURI='"http://www.netzero.com"' isId="true"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens07.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens07"> |
| <metadata> |
| <title>elementsetidattributens07</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNS on the second p element with a non-existing attribute. Verify that |
| NOT_FOUND_ERR is raised. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="employeeElem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="employeeElem" obj="elemList" index="1" interface="NodeList"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <setIdAttributeNS obj="employeeElem" localName='"xsi"' namespaceURI='"http://www.netzero.com"' isId="true"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens08.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens08"> |
| <metadata> |
| <title>elementsetidattributens08</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNS on the second p element with a non-existing attribute. Verify that |
| NOT_FOUND_ERR is raised. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="employeeElem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="employeeElem" obj="elemList" index="1" interface="NodeList"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <setIdAttributeNS obj="employeeElem" localName='"usa"' namespaceURI='"http://www.usa.com"' isId="true"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens09.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens09"> |
| <metadata> |
| <title>elementsetidattributens09</title> |
| <creator>IBM</creator> |
| <description> |
| The method setIdAttributeNS declares the attribute specified by local name and namespace URI to be of type ID. |
| If the value of the specified attribute is unique then this element node can later be retrieved using getElementById on Document. |
| Note, however, that this simply affects this node and does not change any grammar that may be in use. |
| Invoke setIdAttributeNS on the xmlns attribute of ent4. Verify that NO_MODIFICATION_ALLOWED_ERR is raised. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="varElem" type="Element"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entElement" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"var"' namespaceURI='"*"' interface="Document"/> |
| <item interface="NodeList" obj="elemList" var="varElem" index="2"/> |
| <firstChild interface="Node" var="entRef" obj="varElem"/> |
| <firstChild interface="Node" var="entElement" obj="entRef"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <setIdAttributeNS obj="entElement" localName='"xmlns"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="true"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens10.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens10"> |
| <metadata> |
| <title>elementsetidattributens10</title> |
| <creator>IBM</creator> |
| <description> |
| Declares the attribute specified by local name and namespace URI to be of type ID. If the value of the |
| specified attribute is unique then this element node can later be retrieved using getElementById on Document. |
| Note, however, that this simply affects this node and does not change any grammar that may be in use. |
| Invoke setIdAttributeNS on two existing namespace attributes with different values. Verify by calling |
| isId on the attributes and getElementById with different values on document node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="pElem1" type="Element"/> |
| <var name="pElem2" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"p"' namespaceURI='"*"' interface="Document"/> |
| <item var="pElem1" obj="elemList" index="2" interface="NodeList"/> |
| <item var="pElem2" obj="elemList" index="3" interface="NodeList"/> |
| <setIdAttributeNS obj="pElem1" localName='"dmstc"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="true"/> |
| <setIdAttributeNS obj="pElem2" localName='"nm"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="true"/> |
| <attributes var="attributesMap" obj="pElem1"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:dmstc"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsId1True10"/> |
| <attributes var="attributesMap" obj="pElem2"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:nm"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsId2True10"/> |
| <getElementById obj="doc" var="elem" elementId='"http://www.netzero.com"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"p"' id="elementsetidattributens1GetElementById10" ignoreCase="false"/> |
| <getElementById obj="doc" var="elem" elementId='"http://www.altavista.com"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"p"' id="elementsetidattributens2GetElementById10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens11.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens11"> |
| <metadata> |
| <title>elementsetidattributens11</title> |
| <creator>IBM</creator> |
| <description> |
| Declares the attribute specified by local name and namespace URI to be of type ID. If the value of the |
| specified attribute is unique then this element node can later be retrieved using getElementById on Document. |
| Note, however, that this simply affects this node and does not change any grammar that may be in use. |
| Invoke setIdAttributeNS on two existing namespace attributes with same local name but different values. Verify by calling |
| isId on the attributes node and getElementById with different values on document node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="pElem1" type="Element"/> |
| <var name="pElem2" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"p"' namespaceURI='"*"' interface="Document"/> |
| <item var="pElem1" obj="elemList" index="1" interface="NodeList"/> |
| <item var="pElem2" obj="elemList" index="2" interface="NodeList"/> |
| <setIdAttributeNS obj="pElem1" localName='"dmstc"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="true"/> |
| <setIdAttributeNS obj="pElem2" localName='"dmstc"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="true"/> |
| <attributes var="attributesMap" obj="pElem1"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:dmstc"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsId1True11"/> |
| <attributes var="attributesMap" obj="pElem2"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:dmstc"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsId2True11"/> |
| <getElementById obj="doc" var="elem" elementId='"http://www.netzero.com"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"p"' id="elementsetidattributens1GetElementById11" ignoreCase="false"/> |
| <getElementById obj="doc" var="elem" elementId='"http://www.usa.com"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"p"' id="elementsetidattributens2GetElementById11" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens12.xml |
|---|
| 0,0 → 1,70 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens12"> |
| <metadata> |
| <title>elementsetidattributens12</title> |
| <creator>IBM</creator> |
| <description> |
| Declares the attribute specified by local name and namespace URI to be of type ID. If the value of the |
| specified attribute is unique then this element node can later be retrieved using getElementById on Document. |
| Note, however, that this simply affects this node and does not change any grammar that may be in use. |
| Set the noNamespaceSchemaLocation attribute on the first acronym element to "No". Invoke setIdAttributeNS on the |
| noNamespaceSchemaLocation attribute of the first, second and third acronym element. Verify by calling isId on |
| the attributes. Calling getElementById with "No" as a value should return the acronym element. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem1" type="Element"/> |
| <var name="acronymElem2" type="Element"/> |
| <var name="acronymElem3" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"acronym"' namespaceURI='"*"' interface="Document"/> |
| <item var="acronymElem1" obj="elemList" index="0" interface="NodeList"/> |
| <item var="acronymElem2" obj="elemList" index="1" interface="NodeList"/> |
| <item var="acronymElem3" obj="elemList" index="2" interface="NodeList"/> |
| <setAttributeNS obj="acronymElem1" qualifiedName='"xsi:noNamespaceSchemaLocation"' namespaceURI='"http://www.w3.org/2001/XMLSchema-instance"' value='"No"'/> |
| <setIdAttributeNS obj="acronymElem1" localName='"noNamespaceSchemaLocation"' namespaceURI='"http://www.w3.org/2001/XMLSchema-instance"' isId="true"/> |
| <setIdAttributeNS obj="acronymElem2" localName='"noNamespaceSchemaLocation"' namespaceURI='"http://www.w3.org/2001/XMLSchema-instance"' isId="true"/> |
| <setIdAttributeNS obj="acronymElem3" localName='"noNamespaceSchemaLocation"' namespaceURI='"http://www.w3.org/2001/XMLSchema-instance"' isId="true"/> |
| <attributes var="attributesMap" obj="acronymElem1"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xsi:noNamespaceSchemaLocation"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsId1True12"/> |
| <attributes var="attributesMap" obj="acronymElem2"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xsi:noNamespaceSchemaLocation"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsId2True12"/> |
| <attributes var="attributesMap" obj="acronymElem3"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xsi:noNamespaceSchemaLocation"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsId3True12"/> |
| <getElementById obj="doc" var="elem" elementId='"No"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributensGetElementById10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens13.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens13"> |
| <metadata> |
| <title>elementsetidattributens13</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setIdAttributeNS on newly added attribute on the third strong element. Verify by calling |
| isID on the attribute node and getElementById on document node. |
| Call setIdAttributeNS on the same element to reset ID but with a non-existing attribute should generate |
| NOT_FOUND_ERR |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="nameElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="nameElem" obj="elemList" index="2" interface="NodeList"/> |
| <setAttributeNS obj="nameElem" qualifiedName='"xmlns:newAttr"' namespaceURI='"http://www.w3.org/2000/xmlns/"' value='"newValue"'/> |
| <setIdAttributeNS obj="nameElem" localName='"newAttr"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="true"/> |
| <attributes var="attributesMap" obj="nameElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:newAttr"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsIdTrue13"/> |
| <getElementById obj="doc" var="elem" elementId='"newValue"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"strong"' id="elementsetidattributensGetElementById13" ignoreCase="false"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <setIdAttributeNS obj="nameElem" localName='"lang"' namespaceURI='"http://www.w3.org/XML/1998/namespace"' isId="false"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/elementsetidattributens14.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementsetidattributens14"> |
| <metadata> |
| <title>elementsetidattributens14</title> |
| <creator>IBM</creator> |
| <description> |
| Declares the attribute specified by local name and namespace URI to be of type ID. If the value of the |
| specified attribute is unique then this element node can later be retrieved using getElementById on Document. |
| Note, however, that this simply affects this node and does not change any grammar that may be in use. |
| Invoke setIdAttributeNS on two existing attributes of the second p element and the third |
| acronym element. Verify by calling isId on the attributes and getElementById with different values on document node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ElSetIdAttrNS"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="id" type="boolean" value="false"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"p"' namespaceURI='"*"' interface="Document"/> |
| <item var="pElem" obj="elemList" index="1" interface="NodeList"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" localName='"acronym"' namespaceURI='"*"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <setIdAttributeNS obj="pElem" localName='"dmstc"' namespaceURI='"http://www.w3.org/2000/xmlns/"' isId="true"/> |
| <setIdAttributeNS obj="acronymElem" localName='"noNamespaceSchemaLocation"' namespaceURI='"http://www.w3.org/2001/XMLSchema-instance"' isId="true"/> |
| <attributes var="attributesMap" obj="pElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:dmstc"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsId1True14"/> |
| <attributes var="attributesMap" obj="acronymElem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xsi:noNamespaceSchemaLocation"'/> |
| <isId var="id" obj="attr"/> |
| <assertTrue actual="id" id="elementsetidattributensIsId2True14"/> |
| <getElementById obj="doc" var="elem" elementId='"Yes"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"acronym"' id="elementsetidattributens1GetElementById14" ignoreCase="false"/> |
| <getElementById obj="doc" var="elem" elementId='"http://www.usa.com"'/> |
| <tagName obj="elem" var="elemName"/> |
| <assertEquals actual="elemName" expected='"p"' id="elementsetidattributens2GetElementById14" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entities01.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities01"> |
| <metadata> |
| <title>entities01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with entities set to true, check that |
| entity references and unused entity declaration are maintained. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="ent2" type="Entity"/> |
| <var name="doctype" type="DocumentType"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"entities"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <!-- add an entity reference to the content of the p element --> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent1"'/> |
| <appendChild var="child" obj="pElem" newChild="entRef"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <lastChild var="child" obj="pElem" interface="Node"/> |
| <assertNotNull actual="child" id="lastChildNotNull"/> |
| <!-- this should be a Entity Reference node --> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"ent1"' ignoreCase="false" id="firstChild"/> |
| <!-- early drafts would have removed unused entity declarations too --> |
| <doctype var="doctype" obj="doc"/> |
| <entities var="entities" obj="doctype"/> |
| <getNamedItem var="ent2" obj="entities" name='"ent2"'/> |
| <assertNotNull actual="ent2" id="ent2NotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entities02.xml |
|---|
| 0,0 → 1,82 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities02"> |
| <metadata> |
| <title>entities02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with entities set to false, check that |
| entity references are expanded and unused entity declaration are maintained. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="ent2" type="Entity"/> |
| <var name="doctype" type="DocumentType"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"entities"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <!-- add an entity reference to the content of the p element --> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent1"'/> |
| <appendChild var="child" obj="pElem" newChild="entRef"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <lastChild var="child" obj="pElem" interface="Node"/> |
| <assertNotNull actual="child" id="lastChildNotNull"/> |
| <!-- this should be a Text node --> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"#text"' ignoreCase="false" id="firstChildName"/> |
| <nodeValue var="childValue" obj="child"/> |
| <assertEquals actual="childValue" expected='"barfoo"' ignoreCase="false" id="firstChildValue"/> |
| <!-- early drafts would have removed unused entity declarations too --> |
| <doctype var="doctype" obj="doc"/> |
| <entities var="entities" obj="doctype"/> |
| <getNamedItem var="ent2" obj="entities" name='"ent2"'/> |
| <assertNotNull actual="ent2" id="ent2NotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entities03.xml |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities03"> |
| <metadata> |
| <title>entities03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with entities set to false, check that |
| unbound entity references are preserved. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="childType" type="int"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"entities"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <!-- add an entity reference to the content of the p element --> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent3"'/> |
| <appendChild var="child" obj="pElem" newChild="entRef"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <lastChild var="child" obj="pElem" interface="Node"/> |
| <assertNotNull actual="child" id="lastChildNotNull"/> |
| <!-- this should be a Entity Reference node --> |
| <nodeType var="childType" obj="child"/> |
| <assertEquals actual="childType" expected="5" ignoreCase="false" id="lastChildEntRef"/> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"ent3"' ignoreCase="false" id="lastChildName"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entities04.xml |
|---|
| 0,0 → 1,78 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities04"> |
| <metadata> |
| <title>entities04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document using Node.normalize checking that "entities" parameter is ignored. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="ent2" type="Entity"/> |
| <var name="doctype" type="DocumentType"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"entities"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <!-- add an entity reference to the content of the p element --> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent1"'/> |
| <appendChild var="child" obj="pElem" newChild="entRef"/> |
| <normalize obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <lastChild var="child" obj="pElem" interface="Node"/> |
| <assertNotNull actual="child" id="lastChildNotNull"/> |
| <!-- this should be a Entity Reference node --> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"ent1"' ignoreCase="false" id="firstChild"/> |
| <!-- early drafts would have removed unused entity declarations too --> |
| <doctype var="doctype" obj="doc"/> |
| <entities var="entities" obj="doctype"/> |
| <getNamedItem var="ent2" obj="entities" name='"ent2"'/> |
| <assertNotNull actual="ent2" id="ent2NotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetinputencoding01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetinputencoding01"> |
| <metadata> |
| <title>entitygetinputencoding01</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getInputEncoding method on a UTF-8 encoded document and check if the |
| value returned is null for a internal general entity. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-inputEncoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"alpha"'/> |
| <inputEncoding obj="entity" var="encodingName" interface="Entity"/> |
| <assertNull actual="encodingName" id="entitygetinputencoding01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetinputencoding02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetinputencoding02"> |
| <metadata> |
| <title>entitygetinputencoding02</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getInputEncoding method on a UTF-16 encoded document that contains an external |
| unparsed entity and check if the value returned is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-inputEncoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="barfoo_utf16" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"ent5"'/> |
| <inputEncoding obj="entity" var="encodingName" interface="Entity"/> |
| <assertNull actual="encodingName" id="entitygetinputencoding02" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetinputencoding03.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetinputencoding03"> |
| <metadata> |
| <title>entitygetinputencoding03</title> |
| <creator>IBM</creator> |
| <description> |
| Check the value of Entity.inputEncoding on an UTF-16 external entity |
| is either UTF-16 or UTF-16LE |
| </description> |
| <contributor>Neil Delima</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-inputEncoding"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Dec/0045.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="external_barfoo" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"ent1"'/> |
| <inputEncoding obj="entity" var="encodingName" interface="Entity"/> |
| <!-- accept UTF-16LE and UTF-16 as encoding values --> |
| <if> |
| <notEquals actual="encodingName" expected='"UTF-16LE"' ignoreCase="true"/> |
| <assertEquals id="entityIsUTF16orUTF16LE" actual="encodingName" expected='"UTF-16"' ignoreCase="true"/> |
| </if> |
| <!-- check that document's encoding is UTF-8 --> |
| <inputEncoding obj="doc" var="encodingName" interface="Document"/> |
| <assertEquals id="documentIsUTF8" actual="encodingName" expected='"UTF-8"' ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetinputencoding04.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetinputencoding04"> |
| <metadata> |
| <title>entitygetinputencoding04</title> |
| <creator>IBM</creator> |
| <description> |
| Check the value of Entity.inputEncoding on an UTF-8 external entity |
| is UTF-8. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-inputEncoding"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Dec/0045.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="external_barfoo" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"ent2"'/> |
| <inputEncoding obj="entity" var="encodingName" interface="Entity"/> |
| <assertEquals id="entityIsUTF8" actual="encodingName" expected='"UTF-8"' ignoreCase="true"/> |
| <!-- check that document's encoding is UTF-8 --> |
| <inputEncoding obj="doc" var="encodingName" interface="Document"/> |
| <assertEquals id="documentIsUTF8" actual="encodingName" expected='"UTF-8"' ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetxmlencoding01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetxmlencoding01"> |
| <metadata> |
| <title>entitygetxmlencoding01</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getXmlEncoding method on a UTF-8 encoded entity of a document that is not an |
| external parsed entity and check if the value returned is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-encoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"alpha"'/> |
| <xmlEncoding obj="entity" var="encodingName" interface="Entity"/> |
| <assertNull actual="encodingName" id="entitygetxmlencoding01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetxmlencoding02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetxmlencoding02"> |
| <metadata> |
| <title>entitygetxmlencoding02</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getencoding method on a document that contains an external |
| unparsed entity and check if the value returned is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-encoding"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="external_barfoo" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"ent5"'/> |
| <xmlEncoding obj="entity" var="encodingName" interface="Entity"/> |
| <assertNull actual="encodingName" id="entitygetxmlencoding02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetxmlencoding03.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetxmlencoding03"> |
| <metadata> |
| <title>entitygetxmlencoding03</title> |
| <creator>IBM</creator> |
| <description> |
| Check the value of Entity.xmlEncoding on an external entity with an encoding |
| declaration precisely matches the specified value. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-encoding"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Dec/0045.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="external_barfoo" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"ent1"'/> |
| <xmlEncoding obj="entity" var="encodingName" interface="Entity"/> |
| <assertEquals expected='"uTf-16"' actual="encodingName" id="xmlEncoding" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetxmlencoding04.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetxmlencoding04"> |
| <metadata> |
| <title>entitygetxmlencoding04</title> |
| <creator>IBM</creator> |
| <description> |
| Check the value of Entity.xmlEncoding on an external entity without an encoding |
| declaration is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-encoding"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Dec/0045.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="encodingName" type="DOMString"/> |
| <load var="doc" href="external_barfoo" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"ent2"'/> |
| <xmlEncoding obj="entity" var="encodingName" interface="Entity"/> |
| <assertNull actual="encodingName" id="xmlEncoding"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetxmlversion01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetxmlversion01"> |
| <metadata> |
| <title>entitygetxmlversion01</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getXmlVersion method on entity that is not an external entity and check if |
| the value returned is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-version"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="entityVersion" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"epsilon"'/> |
| <xmlVersion obj="entity" var="entityVersion" interface="Entity"/> |
| <assertNull actual="entityVersion" id="entitygetxmlversion01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetxmlversion02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetxmlversion02"> |
| <metadata> |
| <title>entitygetxmlversion02</title> |
| <creator>IBM</creator> |
| <description> |
| Call the getXmlVersion method on a UTF-16 encoded document that contains an external |
| unparsed entity declaration and check if the value returned is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-version"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="entityVersion" type="DOMString"/> |
| <load var="doc" href="barfoo_utf16" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"ent5"'/> |
| <xmlVersion obj="entity" var="entityVersion" interface="Entity"/> |
| <assertNull actual="entityVersion" id="entitygetxmlversion02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetxmlversion03.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetxmlversion03"> |
| <metadata> |
| <title>entitygetxmlversion03</title> |
| <creator>IBM</creator> |
| <description> |
| Check that the value of Entity.xmlVersion on an external entity without |
| a version declaration is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-version"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Dec/0045.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="entityVersion" type="DOMString"/> |
| <load var="doc" href="external_barfoo" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"ent2"'/> |
| <xmlVersion obj="entity" var="entityVersion" interface="Entity"/> |
| <assertNull actual="entityVersion" id="xmlVersionNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/entitygetxmlversion04.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entitygetxmlversion04"> |
| <metadata> |
| <title>entitygetxmlversion04</title> |
| <creator>IBM</creator> |
| <description> |
| Check that the value of Entity.xmlVersion on an external entity with |
| a version declaration is "1.0". |
| </description> |
| <contributor>Neil Delima</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Entity3-version"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom-ts/2003Dec/0045.html"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="entityVersion" type="DOMString"/> |
| <load var="doc" href="external_barfoo" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"ent1"'/> |
| <xmlVersion obj="entity" var="entityVersion" interface="Entity"/> |
| <assertEquals expected='"1.0"' actual="entityVersion" id="xmlVersion10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/.cvsignore |
|---|
| --- test/testcases/tests/level3/core/files/CVS/Entries (nonexistent) |
| +++ test/testcases/tests/level3/core/files/CVS/Entries (revision 4364) |
| @@ -0,0 +1,71 @@ |
| +/.cvsignore/1.2/Fri Apr 3 02:47:59 2009// |
| +/Yes/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/barfoo.svg/1.2/Fri Apr 3 02:47:59 2009// |
| +/barfoo.xhtml/1.4/Fri Apr 3 02:47:59 2009/-kb/ |
| +/barfoo.xml/1.5/Fri Apr 3 02:47:59 2009// |
| +/barfoo_base.svg/1.3/Fri Apr 3 02:47:59 2009// |
| +/barfoo_base.xhtml/1.3/Fri Apr 3 02:47:59 2009/-kb/ |
| +/barfoo_base.xml/1.4/Fri Apr 3 02:47:59 2009// |
| +/barfoo_nodefaultns.svg/1.1/Fri Apr 3 02:47:59 2009// |
| +/barfoo_nodefaultns.xhtml/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/barfoo_nodefaultns.xml/1.2/Fri Apr 3 02:47:59 2009// |
| +/barfoo_standalone_no.svg/1.1/Fri Apr 3 02:47:59 2009// |
| +/barfoo_standalone_no.xhtml/1.4/Fri Apr 3 02:47:59 2009/-kb/ |
| +/barfoo_standalone_no.xml/1.4/Fri Apr 3 02:47:59 2009// |
| +/barfoo_standalone_yes.svg/1.1/Fri Apr 3 02:47:59 2009// |
| +/barfoo_standalone_yes.xhtml/1.4/Fri Apr 3 02:47:59 2009/-kb/ |
| +/barfoo_standalone_yes.xml/1.4/Fri Apr 3 02:47:59 2009// |
| +/barfoo_utf16.svg/1.3/Fri Apr 3 02:47:59 2009/-kb/ |
| +/barfoo_utf16.xhtml/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/barfoo_utf16.xml/1.3/Fri Apr 3 02:47:59 2009/-kb/ |
| +/barfoo_utf8.svg/1.1/Fri Apr 3 02:47:59 2009// |
| +/barfoo_utf8.xhtml/1.4/Fri Apr 3 02:47:59 2009/-kb/ |
| +/barfoo_utf8.xml/1.4/Fri Apr 3 02:47:59 2009// |
| +/canonicalform01.svg/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/canonicalform01.xhtml/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/canonicalform01.xml/1.2/Fri Apr 3 02:47:59 2009// |
| +/canonicalform02.svg/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/canonicalform02.xhtml/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/canonicalform02.xml/1.2/Fri Apr 3 02:47:59 2009// |
| +/canonicalform03.svg/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/canonicalform03.xhtml/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/canonicalform03.xml/1.2/Fri Apr 3 02:47:59 2009// |
| +/canonicalform04.svg/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/canonicalform04.xhtml/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/canonicalform04.xml/1.2/Fri Apr 3 02:47:59 2009// |
| +/canonicalform05.svg/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/canonicalform05.xhtml/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/canonicalform05.xml/1.2/Fri Apr 3 02:47:59 2009// |
| +/datatype_normalization.svg/1.3/Fri Apr 3 02:47:59 2009/-kb/ |
| +/datatype_normalization.svg.xsd/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/datatype_normalization.xml/1.3/Fri Apr 3 02:47:59 2009// |
| +/datatype_normalization.xsd/1.3/Fri Apr 3 02:47:59 2009/-kb/ |
| +/datatype_normalization2.svg/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/datatype_normalization2.svg.xsd/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/datatype_normalization2.xhtml/1.3/Fri Apr 3 02:47:59 2009/-kb/ |
| +/datatype_normalization2.xml/1.3/Fri Apr 3 02:47:59 2009// |
| +/datatype_normalization2.xsd/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/external_barfoo.svg/1.2/Fri Apr 3 02:47:59 2009// |
| +/external_barfoo.xhtml/1.4/Fri Apr 3 02:47:59 2009/-kb/ |
| +/external_barfoo.xml/1.5/Fri Apr 3 02:47:59 2009// |
| +/external_foo.ent/1.1/Fri Apr 3 02:47:59 2009// |
| +/external_foobr.ent/1.1/Fri Apr 3 02:47:59 2009// |
| +/external_widget.ent/1.1/Fri Apr 3 02:47:59 2009// |
| +/hc_nodtdstaff.html/1.2/Fri Apr 3 02:47:59 2009// |
| +/hc_nodtdstaff.svg/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/hc_nodtdstaff.xhtml/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/hc_nodtdstaff.xml/1.2/Fri Apr 3 02:47:59 2009// |
| +/hc_staff.svg/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/hc_staff.svg.xsd/1.1/Fri Apr 3 02:47:59 2009/-kb/ |
| +/hc_staff.xhtml/1.5/Fri Apr 3 02:47:59 2009/-kb/ |
| +/hc_staff.xml/1.6/Fri Apr 3 02:47:59 2009// |
| +/hc_staff.xsd/1.8/Fri Apr 3 02:47:59 2009/-kb/ |
| +/svgtest.js/1.1/Fri Apr 3 02:47:59 2009// |
| +/svgunit.js/1.1/Fri Apr 3 02:47:59 2009// |
| +/typeinfo.svg/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/typeinfo.svg.xsd/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/typeinfo.xhtml/1.3/Fri Apr 3 02:47:59 2009/-kb/ |
| +/typeinfo.xml/1.3/Fri Apr 3 02:47:59 2009// |
| +/typeinfo.xsd/1.2/Fri Apr 3 02:47:59 2009/-kb/ |
| +/xhtml1-strict.dtd/1.4/Fri Apr 3 02:47:59 2009/-kb/ |
| +D |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/core/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/CVS/Template |
|---|
| --- test/testcases/tests/level3/core/files/Yes (nonexistent) |
| +++ test/testcases/tests/level3/core/files/Yes (revision 4364) |
| @@ -0,0 +1,28 @@ |
| +<!-- |
| + |
| +Copyright (c) 2001-2004 World Wide Web Consortium, |
| +(Massachusetts Institute of Technology, Institut National de |
| +Recherche en Informatique et en Automatique, Keio University). All |
| +Rights Reserved. This program is distributed under the W3C's Software |
| +Intellectual Property License. This program is distributed in the |
| +hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| +PURPOSE. |
| + |
| +See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| + |
| +--> |
| + |
| +<!-- |
| + |
| +xsi:noNamespaceSchemaLocation="Yes" appears in hc_staff.xml |
| +but it was not anticipated that "Yes" would be resolved since |
| +there were no elements without a namespace. However, since |
| +at least one processor does attempt to load "Yes", this file |
| +is here to satisfy that request. |
| + |
| +--> |
| + |
| +<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> |
| + <xsd:element name="bogus" type="xsd:string"/> |
| +</xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo.svg |
|---|
| 0,0 → 1,27 |
| <!DOCTYPE svg [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT svg (rect,script,body)> |
| <!ATTLIST svg xmlns CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED |
| fill CDATA #REQUIRED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT body (p)> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| <!ELEMENT br EMPTY> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg"> |
| <rect x="0" y="0" width="100" height="100" fill="blue"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <body xmlns='http://www.w3.org/1999/xhtml'> |
| <p>bar</p> |
| </body> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo.xhtml |
|---|
| 0,0 → 1,25 |
| <!DOCTYPE html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT body (p)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>replaceWholeText sample</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>bar</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo.xml |
|---|
| 0,0 → 1,25 |
| <!DOCTYPE html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT body (p)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>replaceWholeText sample</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>bar</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_base.svg |
|---|
| 0,0 → 1,37 |
| <!DOCTYPE svg [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT svg (rect,script,head,body)> |
| <!ATTLIST svg xmlns CDATA #IMPLIED |
| xml:base CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED |
| fill CDATA #REQUIRED> |
| <!ELEMENT body (p)> |
| <!ATTLIST body |
| xml:base CDATA #IMPLIED |
| xmlns CDATA #IMPLIED |
| id ID #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| <!ELEMENT head (title)> |
| <!ATTLIST head xmlns CDATA #IMPLIED> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg" xml:base="http://www.w3.org/DOM/L3Test"> |
| <rect x="0" y="0" width="100" height="100" fill="blue"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <head xmlns='http://www.w3.org/1999/xhtml'> |
| <title>XML Base sample</title> |
| </head> |
| <body xmlns='http://www.w3.org/1999/xhtml' xml:base="http://www.w3.org/DOM/EmployeeID" id="body"> |
| <p>bar</p><!-- keep comment adjacent to p --> |
| </body> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_base.xhtml |
|---|
| 0,0 → 1,29 |
| <!DOCTYPE html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html |
| xmlns CDATA #IMPLIED |
| xml:base CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT body (p)> |
| <!ATTLIST body xml:base CDATA #IMPLIED |
| id ID #IMPLIED |
| onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml' xml:base="http://www.w3.org/DOM/L3Test"> |
| <head> |
| <title>XML Base sample</title> |
| </head> |
| <body xml:base="http://www.w3.org/DOM/EmployeeID" id="body"> |
| <p>bar</p><!-- keep comment adjacent to p --> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_base.xml |
|---|
| 0,0 → 1,29 |
| <!DOCTYPE html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html |
| xmlns CDATA #IMPLIED |
| xml:base CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT body (p)> |
| <!ATTLIST body xml:base CDATA #IMPLIED |
| id ID #IMPLIED |
| onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml' xml:base="http://www.w3.org/DOM/L3Test"> |
| <head> |
| <title>XML Base sample</title> |
| </head> |
| <body xml:base="http://www.w3.org/DOM/EmployeeID" id="body"> |
| <p>bar</p><!-- keep comment adjacent to p --> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_nodefaultns.svg |
|---|
| 0,0 → 1,28 |
| <!DOCTYPE svg:svg [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT svg:svg (svg:rect,svg:script,html:body)> |
| <!ATTLIST svg:svg xmlns:svg CDATA #IMPLIED> |
| <!ELEMENT svg:rect EMPTY> |
| <!ATTLIST svg:rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED |
| fill CDATA #REQUIRED> |
| <!ELEMENT html:p (#PCDATA|html:br)*> |
| <!ATTLIST html:p class CDATA #IMPLIED> |
| <!ELEMENT html:body (html:p)> |
| <!ATTLIST html:body xmlns:html CDATA #IMPLIED> |
| <!ELEMENT html:br EMPTY> |
| <!ELEMENT svg:script (#PCDATA)> |
| <!ATTLIST svg:script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <svg:svg xmlns:svg="http://www.w3.org/2000/svg"> |
| <svg:rect x="0" y="0" width="100" height="100" fill="blue"/><svg:script type="text/ecmascript">&svgtest;&svgunit;</svg:script> |
| <html:body xmlns:html='http://www.w3.org/1999/xhtml'> |
| <html:p class="visible:false">bar</html:p> |
| </html:body> |
| </svg:svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_nodefaultns.xhtml |
|---|
| 0,0 → 1,26 |
| <!DOCTYPE html:html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html:html (html:head, html:body)> |
| <!ATTLIST html:html xmlns:html CDATA #IMPLIED> |
| <!ELEMENT html:head (html:title,script*)> |
| <!ATTLIST html:head xmlns CDATA #IMPLIED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT html:title (#PCDATA)> |
| <!ELEMENT html:body (html:p)> |
| <!ELEMENT html:p (#PCDATA|html:br)*> |
| <!ATTLIST html:p class CDATA #IMPLIED> |
| <!ELEMENT html:br EMPTY> |
| ]> |
| <html:html xmlns:html='http://www.w3.org/1999/xhtml'> |
| <html:head xmlns='http://www.w3.org/1999/xhtml'> |
| <html:title>test file</html:title> |
| </html:head> |
| <html:body> |
| <html:p class="visible:false">bar</html:p> |
| </html:body> |
| </html:html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_nodefaultns.xml |
|---|
| 0,0 → 1,26 |
| <!DOCTYPE html:html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html:html (html:head, html:body)> |
| <!ATTLIST html:html xmlns:html CDATA #IMPLIED> |
| <!ELEMENT html:head (html:title,script*)> |
| <!ATTLIST html:head xmlns CDATA #IMPLIED> |
| <!ELEMENT html:title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT html:body (html:p)> |
| <!ELEMENT html:p (#PCDATA|html:br)*> |
| <!ATTLIST html:p class CDATA #IMPLIED> |
| <!ELEMENT html:br EMPTY> |
| ]> |
| <html:html xmlns:html='http://www.w3.org/1999/xhtml'> |
| <html:head xmlns='http://www.w3.org/1999/xhtml'> |
| <html:title>test file</html:title> |
| </html:head> |
| <html:body> |
| <html:p class="visible:false">bar</html:p> |
| </html:body> |
| </html:html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_standalone_no.svg |
|---|
| 0,0 → 1,28 |
| <?xml version="1.0" encoding="UTF-8" standalone="no"?> |
| <!DOCTYPE svg [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT svg (rect,script,body)> |
| <!ATTLIST svg xmlns CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED |
| fill CDATA #REQUIRED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT body (p)> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| <!ELEMENT br EMPTY> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg"> |
| <rect x="0" y="0" width="100" height="100" fill="blue"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <body xmlns='http://www.w3.org/1999/xhtml'> |
| <p>bar</p> |
| </body> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_standalone_no.xhtml |
|---|
| 0,0 → 1,26 |
| <?xml version="1.0" encoding="UTF-8" standalone="no"?> |
| <!DOCTYPE html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT body (p)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>replaceWholeText sample</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>bar</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_standalone_no.xml |
|---|
| 0,0 → 1,26 |
| <?xml version="1.0" encoding="UTF-8" standalone="no"?> |
| <!DOCTYPE html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT body (p)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>replaceWholeText sample</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>bar</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_standalone_yes.svg |
|---|
| 0,0 → 1,24 |
| <?xml version="1.0" encoding="UTF-8" standalone="yes"?> |
| <!DOCTYPE svg [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT svg (rect,body)> |
| <!ATTLIST svg xmlns CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED |
| fill CDATA #REQUIRED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT body (p)> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| <!ELEMENT br EMPTY> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg"> |
| <rect x="0" y="0" width="100" height="100" fill="blue"/> |
| <body xmlns='http://www.w3.org/1999/xhtml'> |
| <p>bar</p> |
| </body> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_standalone_yes.xhtml |
|---|
| 0,0 → 1,26 |
| <?xml version="1.0" encoding="UTF-8" standalone="yes"?> |
| <!DOCTYPE html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT body (p)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>getXmlStandalone test doc</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>bar</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_standalone_yes.xml |
|---|
| 0,0 → 1,26 |
| <?xml version="1.0" encoding="UTF-8" standalone="yes"?> |
| <!DOCTYPE html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT body (p)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>getXmlStandalone test doc</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>bar</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_utf16.svg |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_utf16.xhtml |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_utf16.xml |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_utf8.svg |
|---|
| 0,0 → 1,30 |
| <?xml version="1.0" encoding="uTf-8"?> |
| <!DOCTYPE svg [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT svg (rect,script,body)> |
| <!ATTLIST svg xmlns CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED |
| fill CDATA #REQUIRED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT body (p)> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| <!ELEMENT br EMPTY> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg"> |
| <rect x="0" y="0" width="100" height="100" fill="blue"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <body xmlns='http://www.w3.org/1999/xhtml'> |
| <p>bar</p> |
| </body> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_utf8.xhtml |
|---|
| 0,0 → 1,28 |
| <?xml version="1.0" encoding="uTf-8"?> |
| <!DOCTYPE html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT body (p)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>test file</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>bar</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/barfoo_utf8.xml |
|---|
| 0,0 → 1,28 |
| <?xml version="1.0" encoding="uTf-8"?> |
| <!DOCTYPE html [ |
| <!ENTITY ent1 'foo'> |
| <!ENTITY ent2 'foo<br/>'> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT body (p)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ELEMENT br EMPTY> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>test file</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>bar</p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform01.svg |
|---|
| 0,0 → 1,17 |
| <?xml version="1.0"?> |
| <?xml-stylesheet href="doc.xsl" |
| type="text/xsl" ?> |
| <!DOCTYPE svg SYSTEM "xhtml1-strict.dtd"[ |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100" fill="blue"/><script type="text/ecmascript">&svgtest;&svgunit;</script><body xmlns='http://www.w3.org/1999/xhtml'> |
| <p>Hello, world!<!-- Comment 1 --></p></body></svg> |
| <?pi-without-data ?> |
| <!-- Comment 2 --> |
| <!-- Comment 3 --> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform01.xhtml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0"?> |
| <?xml-stylesheet href="doc.xsl" |
| type="text/xsl" ?> |
| <!DOCTYPE html SYSTEM "xhtml1-strict.dtd"> |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform01</title></head><body onload="parent.loadComplete()"> |
| <p>Hello, world!<!-- Comment 1 --></p></body></html> |
| <?pi-without-data ?> |
| <!-- Comment 2 --> |
| <!-- Comment 3 --> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform01.xml |
|---|
| 0,0 → 1,14 |
| <?xml version="1.0"?> |
| <?xml-stylesheet href="doc.xsl" |
| type="text/xsl" ?> |
| <!DOCTYPE html SYSTEM "xhtml1-strict.dtd"> |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform01</title></head><body onload="parent.loadComplete()"> |
| <p>Hello, world!<!-- Comment 1 --></p></body></html> |
| <?pi-without-data ?> |
| <!-- Comment 2 --> |
| <!-- Comment 3 --> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform02.svg |
|---|
| 0,0 → 1,14 |
| <!DOCTYPE svg SYSTEM "xhtml1-strict.dtd"[ |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]><svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100" fill="blue"/><script type="text/ecmascript">&svgtest;&svgunit;</script><body xmlns='http://www.w3.org/1999/xhtml'> |
| <acronym> </acronym> |
| <em> A B </em> |
| <p> |
| A |
| <acronym> </acronym> |
| B |
| <em> A B </em> |
| C |
| </p> |
| </body></svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform02.xhtml |
|---|
| 0,0 → 1,11 |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform02</title></head><body onload="parent.loadComplete()"> |
| <acronym> </acronym> |
| <em> A B </em> |
| <p> |
| A |
| <acronym> </acronym> |
| B |
| <em> A B </em> |
| C |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform02.xml |
|---|
| 0,0 → 1,11 |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform02</title></head><body onload="parent.loadComplete()"> |
| <acronym> </acronym> |
| <em> A B </em> |
| <p> |
| A |
| <acronym> </acronym> |
| B |
| <em> A B </em> |
| C |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform03.svg |
|---|
| 0,0 → 1,22 |
| <!DOCTYPE svg SYSTEM "xhtml1-strict.dtd"[ |
| <!ATTLIST acronym title CDATA "default"> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100" fill="blue"/><script type="text/ecmascript">&svgtest;&svgunit;</script><body xmlns='http://www.w3.org/1999/xhtml'> |
| <br /> |
| <br ></br> |
| <div name = "elem3" id="elem3" /> |
| <div name="elem4" id="elem4" ></div> |
| <div a:attr="out" b:attr="sorted" name="all" class="I'm" |
| xmlns:b="http://www.ietf.org" |
| xmlns:a="http://www.w3.org" |
| xmlns="http://example.org"/> |
| <div xmlns="" xmlns:a="http://www.w3.org"> |
| <div xmlns="http://www.ietf.org"> |
| <div xmlns="" xmlns:a="http://www.w3.org"> |
| <acronym xmlns="" xmlns:a="http://www.ietf.org"/> |
| </div> |
| </div> |
| </div> |
| </body></svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform03.xhtml |
|---|
| 0,0 → 1,18 |
| <!DOCTYPE html [<!ATTLIST acronym title CDATA "default">]> |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform03</title></head><body onload="parent.loadComplete()"> |
| <br /> |
| <br ></br> |
| <div name = "elem3" id="elem3" /> |
| <div name="elem4" id="elem4" ></div> |
| <div a:attr="out" b:attr="sorted" name="all" class="I'm" |
| xmlns:b="http://www.ietf.org" |
| xmlns:a="http://www.w3.org" |
| xmlns="http://example.org"/> |
| <div xmlns="" xmlns:a="http://www.w3.org"> |
| <div xmlns="http://www.ietf.org"> |
| <div xmlns="" xmlns:a="http://www.w3.org"> |
| <acronym xmlns="" xmlns:a="http://www.ietf.org"/> |
| </div> |
| </div> |
| </div> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform03.xml |
|---|
| 0,0 → 1,18 |
| <!DOCTYPE html [<!ATTLIST acronym title CDATA "default">]> |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform03</title></head><body onload="parent.loadComplete()"> |
| <br /> |
| <br ></br> |
| <div name = "elem3" id="elem3" /> |
| <div name="elem4" id="elem4" ></div> |
| <div a:attr="out" b:attr="sorted" name="all" class="I'm" |
| xmlns:b="http://www.ietf.org" |
| xmlns:a="http://www.w3.org" |
| xmlns="http://example.org"/> |
| <div xmlns="" xmlns:a="http://www.w3.org"> |
| <div xmlns="http://www.ietf.org"> |
| <div xmlns="" xmlns:a="http://www.w3.org"> |
| <acronym xmlns="" xmlns:a="http://www.ietf.org"/> |
| </div> |
| </div> |
| </div> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform04.svg |
|---|
| 0,0 → 1,15 |
| <!DOCTYPE svg [ |
| <!ATTLIST div id ID #IMPLIED> |
| <!ATTLIST div class NMTOKENS #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100" fill="blue"/><script type="text/ecmascript">&svgtest;&svgunit;</script><body xmlns='http://www.w3.org/1999/xhtml'> |
| <em>First line
 Second line</em> |
| <acronym>2</acronym> |
| <code><![CDATA[value>"0" && value<"10" ?"valid":"error"]]></code> |
| <code title='value>"0" && value<"10" ?"valid":"error"'>valid</code> |
| <div title=' '   
	 ' '/> |
| <div class=' A   
	 B '/> |
| <div id=' '   
	 ' '/> |
| </body></svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform04.xhtml |
|---|
| 0,0 → 1,13 |
| <!DOCTYPE html [ |
| <!ATTLIST div id ID #IMPLIED> |
| <!ATTLIST div class NMTOKENS #IMPLIED> |
| ]> |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform04</title></head><body onload="parent.loadComplete()"> |
| <em>First line
 Second line</em> |
| <acronym>2</acronym> |
| <code><![CDATA[value>"0" && value<"10" ?"valid":"error"]]></code> |
| <code title='value>"0" && value<"10" ?"valid":"error"'>valid</code> |
| <div title=' '   
	 ' '/> |
| <div class=' A   
	 B '/> |
| <div id=' '   
	 ' '/> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform04.xml |
|---|
| 0,0 → 1,13 |
| <!DOCTYPE html [ |
| <!ATTLIST div id ID #IMPLIED> |
| <!ATTLIST div class NMTOKENS #IMPLIED> |
| ]> |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform04</title></head><body onload="parent.loadComplete()"> |
| <em>First line
 Second line</em> |
| <acronym>2</acronym> |
| <code><![CDATA[value>"0" && value<"10" ?"valid":"error"]]></code> |
| <code title='value>"0" && value<"10" ?"valid":"error"'>valid</code> |
| <div title=' '   
	 ' '/> |
| <div class=' A   
	 B '/> |
| <div id=' '   
	 ' '/> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform05.svg |
|---|
| 0,0 → 1,15 |
| <!DOCTYPE svg [ |
| <!ATTLIST p attrExtEnt ENTITY #IMPLIED> |
| <!ENTITY ent1 "Hello"> |
| <!ENTITY ent2 SYSTEM "world.txt"> |
| <!ENTITY entExt SYSTEM "earth.gif" NDATA gif> |
| <!NOTATION gif SYSTEM "viewgif.exe"> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100" fill="blue"/><script type="text/ecmascript">&svgtest;&svgunit;</script><body xmlns='http://www.w3.org/1999/xhtml'> |
| <p attrExtEnt="entExt"> |
| &ent1;, &ent2;! |
| </p></body></svg> |
| <!-- Let world.txt contain "world" (excluding the quotes) --> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform05.xhtml |
|---|
| 0,0 → 1,13 |
| <!DOCTYPE html [ |
| <!ATTLIST p attrExtEnt ENTITY #IMPLIED> |
| <!ENTITY ent1 "Hello"> |
| <!ENTITY ent2 SYSTEM "world.txt"> |
| <!ENTITY entExt SYSTEM "earth.gif" NDATA gif> |
| <!NOTATION gif SYSTEM "viewgif.exe"> |
| ]> |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform05</title></head><body onload="parent.loadComplete()"> |
| <p attrExtEnt="entExt"> |
| &ent1;, &ent2;! |
| </p></body></html> |
| <!-- Let world.txt contain "world" (excluding the quotes) --> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/canonicalform05.xml |
|---|
| 0,0 → 1,13 |
| <!DOCTYPE html [ |
| <!ATTLIST p attrExtEnt ENTITY #IMPLIED> |
| <!ENTITY ent1 "Hello"> |
| <!ENTITY ent2 SYSTEM "world.txt"> |
| <!ENTITY entExt SYSTEM "earth.gif" NDATA gif> |
| <!NOTATION gif SYSTEM "viewgif.exe"> |
| ]> |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform05</title></head><body onload="parent.loadComplete()"> |
| <p attrExtEnt="entExt"> |
| &ent1;, &ent2;! |
| </p></body></html> |
| <!-- Let world.txt contain "world" (excluding the quotes) --> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/datatype_normalization.svg |
|---|
| 0,0 → 1,89 |
| <!DOCTYPE svg [ |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| <!ELEMENT svg (rect, script, data)> |
| <!ATTLIST svg |
| xmlns CDATA #IMPLIED |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ELEMENT data (double*, boolean*, decimal*, float*, dateTime*, time*)> |
| <!ATTLIST data xmlns CDATA #IMPLIED> |
| <!ELEMENT double (#PCDATA)> |
| <!ATTLIST double |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT boolean (#PCDATA)> |
| <!ATTLIST boolean |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT decimal (#PCDATA)> |
| <!ATTLIST decimal |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT float (#PCDATA)> |
| <!ATTLIST float |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT dateTime (#PCDATA)> |
| <!ATTLIST dateTime |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT time (#PCDATA)> |
| <!ATTLIST time |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg" |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/2000/svg datatype_normalization.svg.xsd"> |
| <rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <data xmlns='http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization'> |
| <double value=" |
| +0003.141592600E+0000 " union=" +0003.141592600E+0000 |
| "> -31415926.00E-7 |
| 2.718</double> |
| <double value=" NaN" union="NaN "> INF -INF </double> |
| <double value=" |
| 1 " union="1 |
| "> -0</double> |
| <boolean value=" |
| true" union="false |
| "> false true false </boolean> |
| <boolean value=" |
| 1" union=" 0 |
| ">0 1 0 </boolean> |
| <decimal value=" +0003.141592600 " union=" +0003.141592600 "> +10 .1 </decimal> |
| <decimal value=" 01 " union=" 01 "> -.001 </decimal> |
| <float value=" +0003.141592600E+0000 " union=" +0003.141592600E+0000 "> -31415926.00E-7 |
| 2.718</float> |
| <float value=" NaN " union=" NaN "> INF -INF </float> |
| <float value=" |
| 1 " union="1 |
| ">-0</float> |
| <dateTime value=" |
| 2004-01-21T15:30:00-05:00" union="2004-01-21T20:30:00-05:00 |
| ">2004-01-21T15:30:00 |
| 2004-01-21T15:30:00Z</dateTime> |
| <dateTime value=" |
| 2004-01-21T15:30:00.0000-05:00" union="2004-01-21T15:30:00.0000-05:00 |
| "> 2004-01-21T15:30:00.0000 </dateTime> |
| <dateTime value="2004-01-21T15:30:00.0001-05:00" union="2004-01-21T15:30:00.0001-05:00">2004-01-21T15:30:00.0001</dateTime> |
| <time value=" |
| 15:30:00-05:00" union="15:30:00-05:00 |
| "> 15:30:00 </time> |
| <time value=" |
| 15:30:00.0000-05:00" union=" 15:30:00.0000-05:00 |
| ">15:30:00.0000</time> |
| <time value=" |
| 15:30:00.0001-05:00" union="15:30:00.0001-05:00 |
| ">15:30:00.0001</time> |
| </data> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/datatype_normalization.svg.xsd |
|---|
| 0,0 → 1,60 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema is attempts to use every construct that could |
| be interrogated by DOM Level 3 and is no way intended to |
| be a general purpose schema for SVG |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/2000/svg" |
| xmlns="http://www.w3.org/2000/svg" |
| xmlns:data="http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"> |
| <xsd:import namespace="http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization" schemaLocation="datatype_normalization.xsd"/> |
| <xsd:element name="svg"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="rect"/> |
| <xsd:element ref="script"/> |
| <xsd:element ref="data:data"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="rect"> |
| <xsd:complexType> |
| <xsd:attribute name="x" type="xsd:double" use="required"/> |
| <xsd:attribute name="y" type="xsd:double" use="required"/> |
| <xsd:attribute name="height" type="xsd:double" use="required"/> |
| <xsd:attribute name="width" type="xsd:double" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="script"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="xsd:string"> |
| <xsd:attribute name="type" type="xsd:string" use="required"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/datatype_normalization.xml |
|---|
| 0,0 → 1,90 |
| <!DOCTYPE svg [ |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| <!ELEMENT svg (rect, script, data)> |
| <!ATTLIST svg |
| xmlns CDATA #IMPLIED |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ELEMENT data (double*, boolean*, decimal*, float*, dateTime*, time*)> |
| <!ATTLIST data xmlns CDATA #IMPLIED> |
| <!ELEMENT double (#PCDATA)> |
| <!ATTLIST double |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT boolean (#PCDATA)> |
| <!ATTLIST boolean |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT decimal (#PCDATA)> |
| <!ATTLIST decimal |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT float (#PCDATA)> |
| <!ATTLIST float |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT dateTime (#PCDATA)> |
| <!ATTLIST dateTime |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT time (#PCDATA)> |
| <!ATTLIST time |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg" |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/2000/svg datatype_normalization.svg.xsd"> |
| <rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <data xmlns='http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization'> |
| <double value=" |
| +0003.141592600E+0000 " union=" +0003.141592600E+0000 |
| "> -31415926.00E-7 |
| 2.718</double> |
| <double value=" NaN" union="NaN "> INF -INF </double> |
| <double value=" |
| 1 " union="1 |
| "> -0</double> |
| <boolean value=" |
| true" union="false |
| "> false true false </boolean> |
| <boolean value=" |
| 1" union=" 0 |
| ">0 1 0 </boolean> |
| <decimal value=" +0003.141592600 " union=" +0003.141592600 "> +10 .1 </decimal> |
| <decimal value=" 01 " union=" 01 "> -.001 </decimal> |
| <float value=" +0003.141592600E+0000 " union=" +0003.141592600E+0000 "> -31415926.00E-7 |
| 2.718</float> |
| <float value=" NaN " union=" NaN "> INF -INF </float> |
| <float value=" |
| 1 " union="1 |
| ">-0</float> |
| <dateTime value=" |
| 2004-01-21T15:30:00-05:00" union="2004-01-21T20:30:00-05:00 |
| ">2004-01-21T15:30:00 |
| 2004-01-21T15:30:00Z</dateTime> |
| <dateTime value=" |
| 2004-01-21T15:30:00.0000-05:00" union="2004-01-21T15:30:00.0000-05:00 |
| "> 2004-01-21T15:30:00.0000 </dateTime> |
| <dateTime value="2004-01-21T15:30:00.0001-05:00" union="2004-01-21T15:30:00.0001-05:00">2004-01-21T15:30:00.0001</dateTime> |
| <time value=" |
| 15:30:00-05:00" union="15:30:00-05:00 |
| "> 15:30:00 </time> |
| <time value=" |
| 15:30:00.0000-05:00" union=" 15:30:00.0000-05:00 |
| ">15:30:00.0000</time> |
| <time value=" |
| 15:30:00.0001-05:00" union="15:30:00.0001-05:00 |
| ">15:30:00.0001</time> |
| </data> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/datatype_normalization.xsd |
|---|
| 0,0 → 1,212 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization" |
| xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"> |
| <xsd:element name="data"> |
| <xsd:complexType> |
| <xsd:choice minOccurs="0" maxOccurs="unbounded"> |
| <xsd:element ref="double"/> |
| <xsd:element ref="boolean"/> |
| <xsd:element ref="decimal"/> |
| <xsd:element ref="float"/> |
| <xsd:element ref="dateTime"/> |
| <xsd:element ref="time"/> |
| </xsd:choice> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myDouble"> |
| <xsd:restriction base="xsd:double"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDoubleList"> |
| <xsd:list itemType="myDouble"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDoubleUnion"> |
| <xsd:union memberTypes="myDouble xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="double"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myDoubleList"> |
| <xsd:attribute name="value" type="myDouble" use="required"/> |
| <xsd:attribute name="union" type="myDoubleUnion" use="required"/> |
| <xsd:attribute name="default" type="myDouble" |
| default="+0003.141592600E+0000" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myBoolean"> |
| <xsd:restriction base="xsd:boolean"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myBooleanList"> |
| <xsd:list itemType="myBoolean"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myBooleanUnion"> |
| <xsd:union memberTypes="myBoolean xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="boolean"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myBooleanList"> |
| <xsd:attribute name="value" type="myBoolean" use="required"/> |
| <xsd:attribute name="union" type="myDoubleUnion" use="required"/> |
| <xsd:attribute name="default" type="myBoolean" |
| default="1" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myDecimal"> |
| <xsd:restriction base="xsd:decimal"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDecimalList"> |
| <xsd:list itemType="myDecimal"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDecimalUnion"> |
| <xsd:union memberTypes="myDecimal xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="decimal"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myDecimalList"> |
| <xsd:attribute name="value" type="myDecimal" use="required"/> |
| <xsd:attribute name="union" type="myDecimalUnion" use="required"/> |
| <xsd:attribute name="default" type="myDecimal" |
| default="+0003.141592600" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myFloat"> |
| <xsd:restriction base="xsd:float"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myFloatList"> |
| <xsd:list itemType="myFloat"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myFloatUnion"> |
| <xsd:union memberTypes="myFloat xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="float"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myFloatList"> |
| <xsd:attribute name="value" type="myFloat" use="required"/> |
| <xsd:attribute name="union" type="myFloatUnion" use="required"/> |
| <xsd:attribute name="default" type="myDouble" |
| default="+0003.141592600E+0000" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myDateTime"> |
| <xsd:restriction base="xsd:dateTime"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDateTimeList"> |
| <xsd:list itemType="myDateTime"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDateTimeUnion"> |
| <xsd:union memberTypes="myDateTime xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="dateTime"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myDateTimeList"> |
| <xsd:attribute name="value" type="myDateTime" use="required"/> |
| <xsd:attribute name="union" type="myDateTimeUnion" use="required"/> |
| <xsd:attribute name="default" type="myDateTime" |
| default="2004-01-21T15:30:00-05:00" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myTime"> |
| <xsd:restriction base="xsd:time"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myTimeList"> |
| <xsd:list itemType="myTime"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myTimeUnion"> |
| <xsd:union memberTypes="myTime xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="time"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myTimeList"> |
| <xsd:attribute name="value" type="myTime" use="required"/> |
| <xsd:attribute name="union" type="myTimeUnion" use="required"/> |
| <xsd:attribute name="default" type="myTime" |
| default="15:30:00-05:00" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myUnion"> |
| <xsd:union memberTypes="xsd:integer xsd:string"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myUnionList"> |
| <xsd:list itemType="myUnion"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myUnionUnion"> |
| <xsd:union memberTypes="myUnion xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="union"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myUnionList"> |
| <xsd:attribute name="value" type="myUnion" use="required"/> |
| <xsd:attribute name="union" type="myUnionUnion" use="required"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/datatype_normalization2.svg |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0"?> |
| <!DOCTYPE svg |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| <!ELEMENT svg (rect, script, body)> |
| <!ATTLIST svg |
| xmlns CDATA #IMPLIED |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg" |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/2000/svg datatype_normalization2.svg.xsd"> |
| <rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script><body xmlns="http://www.w3.org/1999/xhtml"> |
| <p> |
| <!-- preserve, string default --> |
| <em> EMP 0001 </em> |
| <!-- explicit preserve --> |
| <acronym> EMP 0001 </acronym> |
| <!-- explicit collapse --> |
| <code> |
| EMP 0001 |
| </code> |
| <code>EMP 0001</code> |
| <code>EMP 0001</code> |
| <!-- explicit replace --> |
| <sup> |
| EMP 0001 |
| </sup> |
| <sup>EMP 0001</sup> |
| <sup>EMP 0001</sup> |
| <sup>EMP |
| 0001</sup> |
| </p> |
| </body> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/datatype_normalization2.svg.xsd |
|---|
| 0,0 → 1,60 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema is attempts to use every construct that could |
| be interrogated by DOM Level 3 and is no way intended to |
| be a general purpose schema for SVG |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/2000/svg" |
| xmlns="http://www.w3.org/2000/svg" |
| xmlns:xhtml="http://www.w3.org/1999/xhtml"> |
| <xsd:import namespace="http://www.w3.org/1999/xhtml" schemaLocation="datatype_normalization2.xsd"/> |
| <xsd:element name="svg"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="rect"/> |
| <xsd:element ref="script"/> |
| <xsd:element ref="xhtml:body"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="rect"> |
| <xsd:complexType> |
| <xsd:attribute name="x" type="xsd:double" use="required"/> |
| <xsd:attribute name="y" type="xsd:double" use="required"/> |
| <xsd:attribute name="height" type="xsd:double" use="required"/> |
| <xsd:attribute name="width" type="xsd:double" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="script"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="xsd:string"> |
| <xsd:attribute name="type" type="xsd:string" use="required"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/datatype_normalization2.xhtml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml' |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/1999/xhtml datatype_normalization2.xsd"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>datatype_normalization2</title></head><body onload="parent.loadComplete()"> |
| <p> |
| <!-- preserve, string default --> |
| <em> EMP 0001 </em> |
| <!-- explicit preserve --> |
| <acronym> EMP 0001 </acronym> |
| <!-- explicit collapse --> |
| <code> |
| EMP 0001 |
| </code> |
| <code>EMP 0001</code> |
| <code>EMP 0001</code> |
| <!-- explicit replace --> |
| <sup> |
| EMP 0001 |
| </sup> |
| <sup>EMP 0001</sup> |
| <sup>EMP 0001</sup> |
| <sup>EMP |
| 0001</sup> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/datatype_normalization2.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml' |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/1999/xhtml datatype_normalization2.xsd"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>datatype_normalization2</title></head><body onload="parent.loadComplete()"> |
| <p> |
| <!-- preserve, string default --> |
| <em> EMP 0001 </em> |
| <!-- explicit preserve --> |
| <acronym> EMP 0001 </acronym> |
| <!-- explicit collapse --> |
| <code> |
| EMP 0001 |
| </code> |
| <code>EMP 0001</code> |
| <code>EMP 0001</code> |
| <!-- explicit replace --> |
| <sup> |
| EMP 0001 |
| </sup> |
| <sup>EMP 0001</sup> |
| <sup>EMP 0001</sup> |
| <sup>EMP |
| 0001</sup> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/datatype_normalization2.xsd |
|---|
| 0,0 → 1,99 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema is intended to support specific DOM L3 tests is no way intended to |
| be a general purpose schema for XHTML |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/1999/xhtml" |
| xmlns="http://www.w3.org/1999/xhtml"> |
| <xsd:element name="html"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="head"/> |
| <xsd:element ref="body"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="head"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="meta"/> |
| <xsd:element ref="title"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="title" type="xsd:string"/> |
| <xsd:element name="meta"> |
| <xsd:complexType> |
| <xsd:attribute name="http-equiv" type="xsd:string" use="required"/> |
| <xsd:attribute name="content" type="xsd:string" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="body"> |
| <xsd:complexType> |
| <xsd:sequence minOccurs="0" maxOccurs="unbounded"> |
| <xsd:element ref="p"/> |
| </xsd:sequence> |
| <xsd:attribute name="onload" type="xsd:string" use="optional"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="p"> |
| <xsd:complexType> |
| <xsd:choice minOccurs="0" maxOccurs="unbounded"> |
| <xsd:element ref="em"/> |
| <xsd:element ref="code"/> |
| <xsd:element ref="sup"/> |
| <xsd:element ref="acronym"/> |
| </xsd:choice> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="em" type="xsd:string"/> |
| <xsd:simpleType name="acronym"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:whiteSpace value="preserve"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="acronym" type="acronym"/> |
| <xsd:simpleType name="code"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:whiteSpace value="collapse"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="code" type="code"/> |
| <xsd:simpleType name="sup"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:whiteSpace value="replace"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="sup" type="sup"/> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/external_barfoo.svg |
|---|
| 0,0 → 1,31 |
| <!DOCTYPE svg [ |
| <!ENTITY ent1 SYSTEM 'external_foo.ent'> |
| <!ENTITY ent2 SYSTEM 'external_foobr.ent'> |
| <!ENTITY ent3 SYSTEM 'external_widget.ent'> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ELEMENT svg (rect,script,p*)> |
| <!ATTLIST svg xmlns CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED |
| fill CDATA #REQUIRED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ATTLIST p xmlns CDATA #IMPLIED |
| xml:base CDATA #IMPLIED> |
| <!ELEMENT br EMPTY> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg"> |
| <rect x="0" y="0" width="100" height="100" fill="blue"/> |
| <script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <p xmlns='http://www.w3.org/1999/xhtml'>bar&ent2;&ent1;</p> |
| <p xmlns='http://www.w3.org/1999/xhtml' xml:base="http://www.example.com/bogus_base">bar&ent2;&ent1;</p> |
| &ent3; |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/external_barfoo.xhtml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html [ |
| <!ENTITY ent1 SYSTEM 'external_foo.ent'> |
| <!ENTITY ent2 SYSTEM 'external_foobr.ent'> |
| <!ENTITY ent3 SYSTEM 'external_widget.ent'> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT body (p*)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ATTLIST p xml:base CDATA #IMPLIED |
| xmlns CDATA #IMPLIED> |
| <!ELEMENT br EMPTY> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>external entity encoding sample</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>bar&ent2;&ent1;</p> |
| <p xml:base="http://www.example.com/bogus_base">bar&ent2;&ent1;</p> |
| &ent3; |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/external_barfoo.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!DOCTYPE html [ |
| <!ENTITY ent1 SYSTEM 'external_foo.ent'> |
| <!ENTITY ent2 SYSTEM 'external_foobr.ent'> |
| <!ENTITY ent3 SYSTEM 'external_widget.ent'> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (title,script*)> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| src CDATA #IMPLIED |
| type CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| <!ELEMENT body (p*)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|br)*> |
| <!ATTLIST p xml:base CDATA #IMPLIED |
| xmlns CDATA #IMPLIED> |
| <!ELEMENT br EMPTY> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml'> |
| <head> |
| <title>external entity encoding sample</title> |
| </head> |
| <body onload="parent.loadComplete()"> |
| <p>bar&ent2;&ent1;</p> |
| <p xml:base="http://www.example.com/bogus_base">bar&ent2;&ent1;</p> |
| &ent3; |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/external_foo.ent |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/external_foobr.ent |
|---|
| 0,0 → 1,0 |
| <br/>foo |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/external_widget.ent |
|---|
| 0,0 → 1,0 |
| <p xmlns='http://www.w3.org/1999/xhtml'>widget</p> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/hc_nodtdstaff.html |
|---|
| 0,0 → 1,10 |
| <html><head><title>hc_nodtdstaff</title></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/hc_nodtdstaff.svg |
|---|
| 0,0 → 1,10 |
| <svg xmlns='http://www.w3.org/2000/svg'><rect x="0" y="0" width="100" height="100"/><head xmlns='http://www.w3.org/1999/xhtml'><title>hc_nodtdstaff</title></head><body xmlns='http://www.w3.org/1999/xhtml'> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| </body></svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/hc_nodtdstaff.xhtml |
|---|
| 0,0 → 1,10 |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>hc_nodtdstaff</title></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/hc_nodtdstaff.xml |
|---|
| 0,0 → 1,10 |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>hc_nodtdstaff</title></head><body onload="parent.loadComplete()"> |
| <p> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/hc_staff.svg |
|---|
| 0,0 → 1,87 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST p |
| dir CDATA 'rtl' |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED> |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ATTLIST acronym xsi:noNamespaceSchemaLocation CDATA #IMPLIED> |
| <!ENTITY ent4 "<span xmlns='http://www.w3.org/1999/xhtml'>Element data</span><?PItarget PIdata?>"> |
| <!ATTLIST span xmlns CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| <!ELEMENT svg (rect, script, body)> |
| <!ATTLIST svg |
| xmlns CDATA #IMPLIED |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg" |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/2000/svg hc_staff.svg.xsd"> |
| <rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script><body xmlns="http://www.w3.org/1999/xhtml"> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" xsi:noNamespaceSchemaLocation="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0002</em> |
| <strong>Martha Raynolds |
| <![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.netzero.com"> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>&ent4;</var> |
| <acronym title="Yes" class="No" id="_98553" xsi:noNamespaceSchemaLocation="Yes">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p xmlns:nm="http://www.altavista.com"> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα" id="_98556" xsi:noNamespaceSchemaLocation="Yes">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p xmlns:emp2="http://www.nist.gov"> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/hc_staff.svg.xsd |
|---|
| 0,0 → 1,60 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema is attempts to use every construct that could |
| be interrogated by DOM Level 3 and is no way intended to |
| be a general purpose schema for SVG |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/2000/svg" |
| xmlns="http://www.w3.org/2000/svg" |
| xmlns:xhtml="http://www.w3.org/1999/xhtml"> |
| <xsd:import namespace="http://www.w3.org/1999/xhtml" schemaLocation="hc_staff.xsd"/> |
| <xsd:element name="svg"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="rect"/> |
| <xsd:element ref="script"/> |
| <xsd:element ref="xhtml:body"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="rect"> |
| <xsd:complexType> |
| <xsd:attribute name="x" type="xsd:double" use="required"/> |
| <xsd:attribute name="y" type="xsd:double" use="required"/> |
| <xsd:attribute name="height" type="xsd:double" use="required"/> |
| <xsd:attribute name="width" type="xsd:double" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="script"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="xsd:string"> |
| <xsd:attribute name="type" type="xsd:string" use="required"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/hc_staff.xhtml |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST p |
| dir CDATA 'rtl' |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED> |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ATTLIST acronym xsi:noNamespaceSchemaLocation CDATA #IMPLIED> |
| <!ENTITY ent4 "<span xmlns='http://www.w3.org/1999/xhtml'>Element data</span><?PItarget PIdata?>"> |
| <!ATTLIST span xmlns CDATA #IMPLIED> |
| ]> |
| <!-- This is comment number 1.--> |
| <html xmlns='http://www.w3.org/1999/xhtml' |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/1999/xhtml hc_staff.xsd"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title><script type="text/javascript" src="svgunit.js"/><script charset="UTF-8" type="text/javascript" src="svgtest.js"/><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" xsi:noNamespaceSchemaLocation="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0002</em> |
| <strong>Martha Raynolds |
| <![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.netzero.com"> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>&ent4;</var> |
| <acronym title="Yes" class="No" id="_98553" xsi:noNamespaceSchemaLocation="Yes">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p xmlns:nm="http://www.altavista.com"> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα" id="_98556" xsi:noNamespaceSchemaLocation="Yes">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p xmlns:emp2="http://www.nist.gov"> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/hc_staff.xml |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST p |
| dir CDATA 'rtl' |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED> |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ATTLIST acronym xsi:noNamespaceSchemaLocation CDATA #IMPLIED> |
| <!ENTITY ent4 "<span xmlns='http://www.w3.org/1999/xhtml'>Element data</span><?PItarget PIdata?>"> |
| <!ATTLIST span xmlns CDATA #IMPLIED> |
| ]> |
| <!-- This is comment number 1.--> |
| <html xmlns='http://www.w3.org/1999/xhtml' |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/1999/xhtml hc_staff.xsd"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title><script type="text/javascript" src="svgunit.js"/><script charset="UTF-8" type="text/javascript" src="svgtest.js"/><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" xsi:noNamespaceSchemaLocation="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0002</em> |
| <strong>Martha Raynolds |
| <![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.netzero.com"> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>&ent4;</var> |
| <acronym title="Yes" class="No" id="_98553" xsi:noNamespaceSchemaLocation="Yes">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p xmlns:nm="http://www.altavista.com"> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα" id="_98556" xsi:noNamespaceSchemaLocation="Yes">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p xmlns:emp2="http://www.nist.gov"> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/hc_staff.xsd |
|---|
| 0,0 → 1,250 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema is attempts to use every construct that could |
| be interrogated by DOM Level 3 and is no way intended to |
| be a general purpose schema for XHTML |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/1999/xhtml" |
| xmlns="http://www.w3.org/1999/xhtml"> |
| <xsd:element name="html"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="head"/> |
| <xsd:element ref="body"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="head"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="meta"/> |
| <xsd:element ref="title"/> |
| <xsd:element ref="script" minOccurs="0" maxOccurs="unbounded"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="meta"> |
| <xsd:complexType> |
| <xsd:attribute name="http-equiv" type="xsd:string" use="required"/> |
| <xsd:attribute name="content" type="xsd:string" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="script"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="xsd:string"> |
| <xsd:attribute name="src" type="xsd:string" use="optional"/> |
| <xsd:attribute name="charset" type="xsd:string" use="optional"/> |
| <xsd:attribute name="type" type="xsd:string" use="required"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="title" type="xsd:string"/> |
| <xsd:element name="body"> |
| <xsd:complexType> |
| <xsd:sequence minOccurs="0" maxOccurs="unbounded"> |
| <xsd:element ref="p"/> |
| </xsd:sequence> |
| <xsd:attribute name="onload" type="xsd:string" use="optional"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="classType"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="Yes"/> |
| <xsd:enumeration value="No"/> |
| <xsd:enumeration value="Yα"/> |
| <xsd:enumeration value="Y"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:complexType name="part1"> |
| <xsd:sequence> |
| <xsd:element ref="em"/> |
| <xsd:element ref="strong"/> |
| <xsd:element ref="code"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| <xsd:complexType name="pType"> |
| <xsd:complexContent> |
| <xsd:extension base="part1"> |
| <xsd:sequence> |
| <xsd:element ref="sup"/> |
| <xsd:element ref="var"/> |
| <xsd:element ref="acronym"/> |
| </xsd:sequence> |
| <xsd:attribute name="title" type="xsd:string" use="optional"/> |
| <xsd:attribute name="class" type="classType" use="optional"/> |
| <xsd:attribute name="dir" type="dirType" use="optional" default="rtl"/> |
| <xsd:attribute name="foo" type="xsd:string" use="optional"/> |
| </xsd:extension> |
| </xsd:complexContent> |
| </xsd:complexType> |
| <xsd:element name="p"> |
| <xsd:complexType> |
| <xsd:complexContent> |
| <xsd:restriction base="pType"> |
| <xsd:sequence> |
| <xsd:element ref="em"/> |
| <xsd:element ref="strong"/> |
| <xsd:element ref="code"/> |
| <xsd:element ref="sup"/> |
| <xsd:element ref="var"/> |
| <xsd:element ref="acronym"/> |
| </xsd:sequence> |
| <xsd:attribute name="title" type="xsd:string" use="optional"/> |
| <xsd:attribute name="class" type="classType" use="optional"/> |
| <xsd:attribute name="dir" type="dirType" use="optional" default="rtl"/> |
| <xsd:attribute name="foo" type="xsd:string" use="prohibited"/> |
| </xsd:restriction> |
| </xsd:complexContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="emp0001_3Type"> |
| <xsd:restriction base="xsd:ID"> |
| <xsd:enumeration value="EMP0001"/> |
| <xsd:enumeration value="EMP0002"/> |
| <xsd:enumeration value="EMP0003"/> |
| <xsd:enumeration value="EMP0004"/> |
| <xsd:enumeration value="EMP0005"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="emp0004_5Type"> |
| <xsd:restriction base="xsd:ID"> |
| <xsd:enumeration value="EMP0006"/> |
| <xsd:enumeration value="EMP0007"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="unboundedEmType"> |
| <xsd:union memberTypes="emp0001_3Type emp0004_5Type"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="emType"> |
| <xsd:restriction base="unboundedEmType"> |
| <xsd:pattern value="EMP[0-9]*"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="em" type="emType"/> |
| <xsd:simpleType name="unboundedStrongType"> |
| <xsd:list itemType="xsd:string"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="strongType"> |
| <xsd:restriction base="unboundedStrongType"> |
| <xsd:maxLength value="100"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="strong" type="strongType"/> |
| <!-- union of union and union of list --> |
| <xsd:simpleType name="integers"> |
| <xsd:list itemType="xsd:integer"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="sup"> |
| <xsd:union memberTypes="emType integers xsd:string"/> |
| </xsd:simpleType> |
| <xsd:element name="sup" type="sup"/> |
| <!-- list of union of union --> |
| <xsd:simpleType name="supervisoryTitle"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="Specialist"/> |
| <xsd:enumeration value="Director"/> |
| <xsd:enumeration value="Manager"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="nonSupervisoryTitle"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="Accountant"/> |
| <xsd:enumeration value="Secretary"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="title"> |
| <xsd:union memberTypes="supervisoryTitle nonSupervisoryTitle"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="field"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="Department"/> |
| <xsd:enumeration value="Personnel"/> |
| <xsd:enumeration value="Computer"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="codeItem"> |
| <xsd:union memberTypes="field title"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="code"> |
| <xsd:list itemType="codeItem"/> |
| </xsd:simpleType> |
| <xsd:element name="code" type="code"/> |
| <xsd:element name="span" type="xsd:string"/> |
| <xsd:complexType name="var" mixed="true"> |
| <xsd:sequence> |
| <xsd:element ref="span" minOccurs="0"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| <xsd:element name="var" type="var"/> |
| <xsd:simpleType name="dirType"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="ltr"/> |
| <xsd:enumeration value="rtl"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="acronym"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="xsd:string"> |
| <xsd:attribute name="class" type="classType" use="optional"/> |
| <xsd:attribute name="title" type="xsd:string" use="optional"/> |
| <xsd:attribute name="id" type="xsd:ID" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/typeinfo.svg |
|---|
| 0,0 → 1,29 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| <!ELEMENT svg (rect, script, body)> |
| <!ATTLIST svg |
| xmlns CDATA #IMPLIED |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg" |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/2000/svg typeinfo.svg.xsd"> |
| <rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script><body xmlns="http://www.w3.org/1999/xhtml"> |
| <p id="foo1"><strong>foo1 foo2</strong></p> |
| <p id="foo2"><code>1</code><code>unbounded</code></p> |
| <p><em>127</em><em>48</em></p> |
| <p><acronym>3.1415926 2.718</acronym></p> |
| </body> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/typeinfo.svg.xsd |
|---|
| 0,0 → 1,60 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema is attempts to use every construct that could |
| be interrogated by DOM Level 3 and is no way intended to |
| be a general purpose schema for SVG |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/2000/svg" |
| xmlns="http://www.w3.org/2000/svg" |
| xmlns:xhtml="http://www.w3.org/1999/xhtml"> |
| <xsd:import namespace="http://www.w3.org/1999/xhtml" schemaLocation="typeinfo.xsd"/> |
| <xsd:element name="svg"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="rect"/> |
| <xsd:element ref="script"/> |
| <xsd:element ref="xhtml:body"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="rect"> |
| <xsd:complexType> |
| <xsd:attribute name="x" type="xsd:double" use="required"/> |
| <xsd:attribute name="y" type="xsd:double" use="required"/> |
| <xsd:attribute name="height" type="xsd:double" use="required"/> |
| <xsd:attribute name="width" type="xsd:double" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="script"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="xsd:string"> |
| <xsd:attribute name="type" type="xsd:string" use="required"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/typeinfo.xhtml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"[ |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml' |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/1999/xhtml typeinfo.xsd"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title></head> |
| <body onload="parent.loadComplete()"> |
| <p id="foo1"><strong>foo1 foo2</strong></p> |
| <p id="foo2"><code>1</code><code>unbounded</code></p> |
| <p><em>127</em><em>48</em></p> |
| <p><acronym>3.1415926 2.718</acronym></p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/typeinfo.xml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd"[ |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml' |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/1999/xhtml typeinfo.xsd"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title></head> |
| <body onload="parent.loadComplete()"> |
| <p id="foo1"><strong>foo1 foo2</strong></p> |
| <p id="foo2"><code>1</code><code>unbounded</code></p> |
| <p><em>127</em><em>48</em></p> |
| <p><acronym>3.1415926 2.718</acronym></p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/typeinfo.xsd |
|---|
| 0,0 → 1,107 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema provides supports misc_typeinfo.xml |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/1999/xhtml" |
| xmlns="http://www.w3.org/1999/xhtml"> |
| <xsd:element name="html"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="head"/> |
| <xsd:element ref="body"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="head"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="meta"/> |
| <xsd:element ref="title"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="title" type="xsd:string"/> |
| <xsd:element name="meta"> |
| <xsd:complexType> |
| <xsd:attribute name="http-equiv" type="xsd:string" use="required"/> |
| <xsd:attribute name="content" type="xsd:string" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="body"> |
| <xsd:complexType> |
| <xsd:sequence minOccurs="0" maxOccurs="unbounded"> |
| <xsd:element ref="p"/> |
| </xsd:sequence> |
| <xsd:attribute name="onload" type="xsd:string" use="optional"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="p"> |
| <xsd:complexType> |
| <xsd:choice minOccurs="0" maxOccurs="unbounded"> |
| <xsd:element ref="em"/> |
| <xsd:element ref="strong"/> |
| <xsd:element ref="code"/> |
| <xsd:element ref="acronym"/> |
| </xsd:choice> |
| <xsd:attribute name="id" type="xsd:ID" use="optional"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="strong" type="xsd:IDREFS"/> |
| <xsd:element name="em" type="xsd:byte"/> |
| <xsd:simpleType name="unbounded"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="unbounded"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="unsignedIntOrUnbounded"> |
| <xsd:union memberTypes="xsd:unsignedInt unbounded"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="doubleList"> |
| <xsd:list itemType="xsd:double"/> |
| </xsd:simpleType> |
| <xsd:element name="acronym"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="doubleList"> |
| <xsd:attribute name="id" use="optional" type="xsd:ID"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="code"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="unsignedIntOrUnbounded"> |
| <xsd:attribute name="id" type="xsd:ID" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/files/xhtml1-strict.dtd |
|---|
| 0,0 → 1,65 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This is a radically simplified DTD for use in the DOM Test Suites |
| due to a XML non-conformance of one implementation in processing |
| parameter entities. When that non-conformance is resolved, |
| this DTD can be replaced by the normal DTD for XHTML. |
| --> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (meta,title,script*)> |
| <!ELEMENT meta EMPTY> |
| <!ATTLIST meta |
| http-equiv CDATA #IMPLIED |
| content CDATA #IMPLIED> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT body (p*)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|em|strong|code|sup|var|acronym|abbr)*> |
| <!ATTLIST p |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT em (#PCDATA)> |
| <!ELEMENT span (#PCDATA)> |
| <!ELEMENT strong (#PCDATA)> |
| <!ELEMENT code (#PCDATA)> |
| <!ELEMENT sup (#PCDATA)> |
| <!ELEMENT var (#PCDATA|span)*> |
| <!ELEMENT acronym (#PCDATA)> |
| <!ATTLIST acronym |
| title CDATA #IMPLIED |
| class CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT abbr (#PCDATA)> |
| <!ATTLIST abbr |
| title CDATA #IMPLIED |
| class CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| type CDATA #IMPLIED |
| src CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/handleerror01.xml |
|---|
| 0,0 → 1,91 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="handleerror01"> |
| <metadata> |
| <title>handleerror01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add two CDATASection containing "]]>" and call Node.normalize |
| with an error handler that stops processing. Only one of the |
| CDATASections should be split. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-split-cdata-sections"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ERRORS-DOMErrorHandler-handleError"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="newChild" type="CDATASection"/> |
| <var name="oldChild" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="childType" type="int"/> |
| <var name="retval" type="Node"/> |
| <var name="errors" type="List"/> |
| <var name="errorHandler" type="DOMErrorHandler"> |
| <handleError> |
| <!-- returning false should stop processing --> |
| <return value="false"/> |
| </handleError> |
| </var> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <!-- have two invalid CDATASections as the content for the p element --> |
| <firstChild var="oldChild" obj="elem" interface="Node"/> |
| <createCDATASection var="newChild" obj="doc" data='"this is not ]]> good"'/> |
| <replaceChild var="retval" obj="elem" newChild="newChild" oldChild="oldChild"/> |
| <createCDATASection var="newChild" obj="doc" data='"this is not ]]> bad"'/> |
| <appendChild var="retval" obj="elem" newChild="newChild"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"split-cdata-sections"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorHandler"/> |
| <!-- normalization should have been stopped after |
| so one of the cdata sections should be intact --> |
| <normalizeDocument obj="doc"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <lastChild var="child" obj="elem" interface="Node"/> |
| <nodeValue var="childValue" obj="child"/> |
| <if> |
| <!-- if last child matches original test --> |
| <equals actual="childValue" expected='"this is not ]]> bad"' ignoreCase="false"/> |
| <!-- check that it is a CDATASection --> |
| <nodeType var="childType" obj="child"/> |
| <assertEquals actual="childType" expected="4" ignoreCase="false" id="lastChildCDATA"/> |
| <!-- check that first child is not intact --> |
| <firstChild var="child" obj="elem" interface="Node"/> |
| <nodeValue var="childValue" obj="child"/> |
| <assertNotEquals actual="childValue" expected='"this is not ]]> good"' |
| ignoreCase="false" id="firstChildNotIntact"/> |
| <else> |
| <!-- last child was split, check that first child is intact --> |
| <firstChild var="child" obj="elem" interface="Node"/> |
| <nodeValue var="childValue" obj="child"/> |
| <assertEquals actual="childValue" expected='"this is not ]]> good"' |
| ignoreCase="false" id="firstChildIntact"/> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/handleerror02.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="handleerror02"> |
| <metadata> |
| <title>handleerror02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with two DOM L1 nodes. |
| Use an error handler to continue from errors and check that more than one |
| error was reported. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespaces"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-ERRORS-DOMErrorHandler-handleError"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <var name="brElem" type="Element"/> |
| <var name="errors" type="List"/> |
| <var name="errorHandler" type="DOMErrorHandler"> |
| <!-- instance scope variables, |
| value attributes are passed via constructor --> |
| <var name="errors" type="List" value="errors"/> |
| <handleError> |
| <var name="severity" type="int"/> |
| <severity var="severity" obj="error"/> |
| <if><equals actual="severity" expected="2" ignoreCase="false"/> |
| <append collection="errors" item="error"/> |
| </if> |
| <return value="true"/> |
| </handleError> |
| </var> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorHandler"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <createElement var="brElem" obj="doc" tagName='"br"'/> |
| <appendChild var="retval" obj="pElem" newChild="brElem"/> |
| <createElement var="brElem" obj="doc" tagName='"br"'/> |
| <appendChild var="retval" obj="pElem" newChild="brElem"/> |
| <normalizeDocument obj="doc"/> |
| <assertSize id="twoErrors" size="2" collection="errors"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/hasFeature01.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="hasFeature01"> |
| <metadata> |
| <title>hasFeature01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementation.hasFeature("XML", "3.0") should return true. |
| </description> |
| <date qualifier="created">2003-05-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-5CED94D7"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="impl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <implementation var="impl"/> |
| <hasFeature var="state" obj="impl" feature='"xMl"' version='"3.0"'/> |
| <assertTrue id="hasXML30" actual="state"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/hasFeature02.xml |
|---|
| 0,0 → 1,32 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="hasFeature02"> |
| <metadata> |
| <title>hasFeature02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementation.hasFeature("XML", "3.0") should return true. |
| </description> |
| <date qualifier="created">2003-05-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="impl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <implementation var="impl"/> |
| <hasFeature var="state" obj="impl" feature='"cOrE"' version='"3.0"'/> |
| <assertTrue id="hasCore30" actual="state"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/hasFeature03.xml |
|---|
| 0,0 → 1,32 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="hasFeature03"> |
| <metadata> |
| <title>hasFeature03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementation.hasFeature("XML", "3.0") should return true. |
| </description> |
| <date qualifier="created">2003-05-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="impl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <implementation var="impl"/> |
| <hasFeature var="state" obj="impl" feature='"+cOrE"' version='"3.0"'/> |
| <assertTrue id="hasPlusCore30" actual="state"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/hasFeature04.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="hasFeature04"> |
| <metadata> |
| <title>hasFeature04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementation.hasFeature("XML", "3.0") should return true. |
| </description> |
| <date qualifier="created">2003-05-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-5CED94D7"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="impl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <implementation var="impl"/> |
| <hasFeature var="state" obj="impl" feature='"+xMl"' version='"3.0"'/> |
| <assertTrue id="hasXML30" actual="state"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/infoset01.xml |
|---|
| 0,0 → 1,82 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset01"> |
| <metadata> |
| <title>infoset01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with infoset set to true, check that |
| entity references are expanded and unused entity declaration are maintained. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="ent2" type="Entity"/> |
| <var name="doctype" type="DocumentType"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <!-- add an entity reference to the content of the p element --> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent1"'/> |
| <appendChild var="child" obj="pElem" newChild="entRef"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <lastChild var="child" obj="pElem" interface="Node"/> |
| <assertNotNull actual="child" id="lastChildNotNull"/> |
| <!-- this should be a Text node --> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"#text"' ignoreCase="false" id="firstChildName"/> |
| <nodeValue var="childValue" obj="child"/> |
| <assertEquals actual="childValue" expected='"barfoo"' ignoreCase="false" id="firstChildValue"/> |
| <!-- early drafts would have removed unused entity declarations too --> |
| <doctype var="doctype" obj="doc"/> |
| <entities var="entities" obj="doctype"/> |
| <getNamedItem var="ent2" obj="entities" name='"ent2"'/> |
| <assertNotNull actual="ent2" id="ent2NotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/infoset02.xml |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset02"> |
| <metadata> |
| <title>infoset02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with infoset set to true, check that |
| unbound entity references are preserved. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="childType" type="int"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <!-- add an entity reference to the content of the p element --> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent3"'/> |
| <appendChild var="child" obj="pElem" newChild="entRef"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="pList" |
| obj="doc" |
| tagname='"p"' |
| interface="Document"/> |
| <item var="pElem" obj="pList" interface="NodeList" index="0"/> |
| <lastChild var="child" obj="pElem" interface="Node"/> |
| <assertNotNull actual="child" id="lastChildNotNull"/> |
| <!-- this should be a Entity Reference node --> |
| <nodeType var="childType" obj="child"/> |
| <assertEquals actual="childType" expected="5" ignoreCase="false" id="lastChildEntRef"/> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"ent3"' ignoreCase="false" id="lastChildName"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/infoset03.xml |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset03"> |
| <metadata> |
| <title>infoset03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with infoset set to true, |
| check if string values were not normalized. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="childLength" type="int"/> |
| <load var="doc" href="datatype_normalization2" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"code"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <length var="childLength" obj="childValue" interface="DOMString"/> |
| <assertEquals actual="childLength" expected='18' ignoreCase="false" id="content1"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content2"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content3"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/infoset04.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset04"> |
| <metadata> |
| <title>infoset04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize a document with a created CDATA section with the |
| 'infoset' to true and check if |
| the CDATASection has been coalesced. |
| </description> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=416"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="newCdata" type="CDATASection"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="text" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <createCDATASection var="newCdata" obj="doc" data='"CDATA"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="newCdata"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalization2Error"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <lastChild var="text" obj="elem" interface="Node"/> |
| <nodeName var="nodeName" obj="text"/> |
| <assertEquals actual="nodeName" expected='"#text"' id="documentnormalizedocument03_false" ignoreCase="false"/> |
| <nodeValue var="nodeValue" obj="text"/> |
| <assertEquals actual="nodeValue" expected='"barCDATA"' id="normalizedValue" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/infoset05.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset05"> |
| <metadata> |
| <title>infoset05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with infoset set to true, check that |
| namespace declaration attributes are maintained. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="xmlnsAttr" type="Attr"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getAttributeNode var="xmlnsAttr" obj="docElem" name='"xmlns"'/> |
| <assertNotNull actual="xmlnsAttr" id="xmlnsAttrNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/infoset06.xml |
|---|
| 0,0 → 1,88 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset06"> |
| <metadata> |
| <title>infoset06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a document with an XML 1.1 valid but XML 1.0 invalid element and |
| normalize document with infoset set to true. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullString" type="DOMString" isNull="true"/> |
| <var name="nullDoctype" type="DocumentType" isNull="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="retval" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="locator" type="DOMLocator"/> |
| <var name="relatedNode" type="Node"/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" |
| namespaceURI="nullString" |
| qualifiedName="nullString" |
| doctype="nullDoctype"/> |
| <assertDOMException id="xml10InvalidName"> |
| <INVALID_CHARACTER_ERR> |
| <createElementNS var="elem" obj="doc" |
| namespaceURI='"http://www.example.org/domts/wellformed01"' |
| qualifiedName='"LegalNameࢎ"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| <try> |
| <xmlVersion obj="doc" value='"1.1"' interface="Document"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <createElementNS var="elem" obj="doc" |
| namespaceURI='"http://www.example.org/domts/wellformed01"' |
| qualifiedName='"LegalNameࢎ"'/> |
| <appendChild var="retval" obj="doc" newChild="elem"/> |
| <xmlVersion obj="doc" value='"1.0"' interface="Document"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <assertEquals actual="severity" expected="2" ignoreCase="false" id="severity"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <assertEquals actual="type" expected='"wf-invalid-character-in-node-name"' |
| ignoreCase="false" id="type"/> |
| <location var="locator" obj="error" interface="DOMError"/> |
| <relatedNode var="relatedNode" obj="locator" interface="DOMLocator"/> |
| <assertSame actual="relatedNode" expected="elem" id="relatedNode"/> |
| </for-each> |
| <assertSize size="1" collection="errors" id="oneError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/infoset07.xml |
|---|
| 0,0 → 1,86 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset07"> |
| <metadata> |
| <title>infoset07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a document with an XML 1.1 valid but XML 1.0 invalid attribute and |
| normalize document with infoset set to true. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDoctype" type="DocumentType" isNull="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="retval" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="locator" type="DOMLocator"/> |
| <var name="relatedNode" type="Node"/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| qualifiedName='"html"' |
| doctype="nullDoctype"/> |
| <documentElement var="docElem" obj="doc"/> |
| <assertDOMException id="xml10InvalidName"> |
| <INVALID_CHARACTER_ERR> |
| <createAttribute var="attr" obj="doc" |
| name='"LegalNameࢎ"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| <try> |
| <xmlVersion obj="doc" value='"1.1"' interface="Document"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <setAttribute obj="docElem" name='"LegalNameࢎ"' value='"foo"'/> |
| <getAttributeNode var="attr" obj="docElem" name='"LegalNameࢎ"'/> |
| <xmlVersion obj="doc" value='"1.0"' interface="Document"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <assertEquals actual="severity" expected="2" ignoreCase="false" id="severity"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <assertEquals actual="type" expected='"wf-invalid-character-in-node-name"' |
| ignoreCase="false" id="type"/> |
| <location var="locator" obj="error" interface="DOMError"/> |
| <relatedNode var="relatedNode" obj="locator" interface="DOMLocator"/> |
| <assertSame actual="relatedNode" expected="attr" id="relatedNode"/> |
| </for-each> |
| <assertSize size="1" collection="errors" id="oneError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/infoset08.xml |
|---|
| 0,0 → 1,78 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset08"> |
| <metadata> |
| <title>infoset08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with infoset and validation set to true, check that |
| whitespace in element content is preserved. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="body" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="child" type="Node"/> |
| <var name="childName" type="DOMString"/> |
| <var name="text" type="Text"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <!-- if we discarded whitespace on parse, add some back --> |
| <if><implementationAttribute name="ignoringElementContentWhitespace" value="true"/> |
| <getElementsByTagName |
| var="bodyList" |
| obj="doc" |
| tagname='"body"' |
| interface="Document"/> |
| <item var="body" obj="bodyList" interface="NodeList" index="0"/> |
| <firstChild var="child" obj="body" interface="Node"/> |
| <createTextNode var="text" obj="doc" data='" "'/> |
| <insertBefore var="child" obj="body" newChild="text" refChild="child"/> |
| </if> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName |
| var="bodyList" |
| obj="doc" |
| tagname='"body"' |
| interface="Document"/> |
| <item var="body" obj="bodyList" interface="NodeList" index="0"/> |
| <firstChild var="child" obj="body" interface="Node"/> |
| <assertNotNull actual="child" id="firstChildNotNull"/> |
| <!-- this should be a Text node --> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"#text"' ignoreCase="false" id="firstChild"/> |
| <nextSibling var="child" obj="child" interface="Node"/> |
| <assertNotNull actual="child" id="secondChildNotNull"/> |
| <nodeName var="childName" obj="child"/> |
| <assertEquals actual="childName" expected='"p"' ignoreCase="false" id="secondChild"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/infoset09.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset09"> |
| <metadata> |
| <title>infoset09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Append a Comment node and normalize with "infoset" set to true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-infoset"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="newComment" type="Comment"/> |
| <var name="lastChild" type="Node"/> |
| <var name="text" type="Text"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <createComment var="newComment" obj="doc" data='"COMMENT_NODE"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="newComment"/> |
| <domConfig interface="Document" obj="doc" var="domConfig" /> |
| <setParameter obj="domConfig" name='"comments"' value="false"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="normalizationError"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="pList" index="0" interface="NodeList"/> |
| <lastChild var="lastChild" obj="elem" interface="Node"/> |
| <nodeName var="nodeName" obj="lastChild"/> |
| <assertEquals actual="nodeName" expected='"#comment"' id="commentPreserved" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/metadata.xml |
|---|
| 0,0 → 1,19 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE metadata SYSTEM "dom3.dtd"> |
| <!-- This file contains additional metadata about DOM L3 Core tests. |
| Allowing additional documentation without modifying the tests themselves. --> |
| <metadata xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3"> |
| </metadata> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/namespacedeclarations01.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="namespacedeclarations01"> |
| <metadata> |
| <title>namespacedeclarations01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with namespace-declarations set to true, check that |
| namespace declaration attributes are maintained. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespace-declarations"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="xmlnsAttr" type="Attr"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"namespace-declarations"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getAttributeNode var="xmlnsAttr" obj="docElem" name='"xmlns"'/> |
| <assertNotNull actual="xmlnsAttr" id="xmlnsAttrNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/namespacedeclarations02.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="namespacedeclarations02"> |
| <metadata> |
| <title>namespacedeclarations02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with namespace-declarations set to true, check that |
| namespace declaration attributes are maintained. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespace-declarations"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="xmlnsAttr" type="Attr"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"namespace-declarations"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getAttributeNode var="xmlnsAttr" obj="docElem" name='"xmlns"'/> |
| <assertNull actual="xmlnsAttr" id="xmlnsAttrNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeappendchild01.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeappendchild01"> |
| <metadata> |
| <title>nodeappendchild01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An attempt to add a second doctype node should result in a HIERARCHY_REQUEST_ERR |
| or a NOT_SUPPORTED_ERR. |
| </description> |
| <date qualifier="created">2004-01-22</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="nullPubId" type="DOMString" isNull="true"/> |
| <var name="nullSysId" type="DOMString" isNull="true"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="tagName" type="DOMString"/> |
| <var name="docElem" type="Element"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="tagName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="docType" obj="domImpl" qualifiedName='tagName' publicId="nullPubId" systemId="nullSysId"/> |
| <try> |
| <appendChild obj="doc" var="appendedChild" newChild="docType"/> |
| <fail id="throw_HIERARCHY_REQUEST_OR_NOT_SUPPORTED"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NOT_SUPPORTED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeappendchild02.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeappendchild02"> |
| <metadata> |
| <title>nodeappendchild02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| An attempt to add a second document element should result in a HIERARCHY_REQUEST_ERR |
| or a NOT_SUPPORTED_ERR. |
| </description> |
| <date qualifier="created">2004-01-22</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-184E7107"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newElem" type="Element"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="tagName" type="DOMString"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="docElem" type="Element"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="tagName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <createElementNS var="newElem" obj="doc" qualifiedName='tagName' namespaceURI="rootNS"/> |
| <try> |
| <appendChild obj="doc" var="appendedChild" newChild="newElem"/> |
| <fail id="throw_HIERARCHY_REQUEST_OR_NOT_SUPPORTED"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NOT_SUPPORTED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition01.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition01"> |
| <metadata> |
| <title>nodecomparedocumentposition01</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if a Document node contains and precedes its documentType and |
| node and if the DocumentTypeNode is contained and follows its Document node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-18</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="documentPositionDoc" type="int"/> |
| <var name="documentPositionDocType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <compareDocumentPosition var="documentPositionDoc" obj="doc" other="docType"/> |
| <assertEquals actual="documentPositionDoc" expected="20" id="nodecomparedocumentpositionIsContainedFollowing01" ignoreCase="false"/> |
| <compareDocumentPosition var="documentPositionDocType" obj="docType" other="doc"/> |
| <assertEquals actual="documentPositionDocType" expected="10" id="nodecomparetreepositionContainsPRECEDING01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition02.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition02"> |
| <metadata> |
| <title>nodecomparedocumentposition02</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if a Document node contains and precedes its new DocumentType and |
| node and if the new DocumentType Node is contained and follows its Document node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDocType" type="DocumentType"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="documentPositionDoc" type="int"/> |
| <var name="documentPositionDocType" type="int"/> |
| <var name="nullPubId" type="DOMString" isNull="true"/> |
| <var name="nullSysId" type="DOMString" isNull="true"/> |
| <var name="replaced" type="Node"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <name var="rootName" obj="docType" interface="DocumentType"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="newDocType" obj="domImpl" qualifiedName="rootName" publicId="nullPubId" systemId="nullSysId"/> |
| <replaceChild obj="doc" var="replaced" newChild="newDocType" oldChild="docType"/> |
| <compareDocumentPosition var="documentPositionDoc" obj="doc" other="newDocType"/> |
| <assertEquals actual="documentPositionDoc" expected="20" id="nodecomparedocumentpositionIsContainedFollowing02" ignoreCase="false"/> |
| <compareDocumentPosition var="documentPositionDocType" obj="newDocType" other="doc"/> |
| <assertEquals actual="documentPositionDocType" expected="10" id="nodecomparedocumentpositionContainsPRECEDING02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition03.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition03"> |
| <metadata> |
| <title>nodecomparedocumentposition03</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the document position of two Document nodes obtained from the |
| same xml document is disconnected, implementation specific, and that the order of these two documents |
| is reserved. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docComp" type="Document"/> |
| <var name="documentPosition1" type="int"/> |
| <var name="documentPosition2" type="int"/> |
| <var name="documentPosition3" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <load var="docComp" href="hc_staff" willBeModified="false"/> |
| <compareDocumentPosition var="documentPosition1" obj="doc" other="docComp"/> |
| <!-- bitmask blocks out preceding and following bits --> |
| <assertEquals bitmask="57" actual="documentPosition1" expected="33" id="isImplSpecificDisconnected1" ignoreCase="false"/> |
| <compareDocumentPosition var="documentPosition2" obj="docComp" other="doc"/> |
| <assertNotEquals bitmask="2" actual="documentPosition2" expected="documentPosition1" id="notBothPreceding" ignoreCase="false"/> |
| <assertNotEquals bitmask="4" actual="documentPosition2" expected="documentPosition1" id="notBothFollowing" ignoreCase="false"/> |
| <assertEquals bitmask="57" actual="documentPosition2" expected="33" id="isImplSpecificDisconnected2" ignoreCase="false"/> |
| <!-- returned value should be consistent between invocations --> |
| <compareDocumentPosition var="documentPosition3" obj="doc" other="docComp"/> |
| <assertEquals actual="documentPosition3" expected="documentPosition1" id="isConsistent" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition04.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition04"> |
| <metadata> |
| <title>nodecomparedocumentposition04</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check that no flags are set in return when the document position of a |
| Document node is compared with itself |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="documentPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <compareDocumentPosition var="documentPosition" obj="doc" other="doc"/> |
| <assertEquals actual="documentPosition" expected="0" id="nodecomparedocumentpositionNoFlags04" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition05.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition05"> |
| <metadata> |
| <title>nodecomparedocumentposition05</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the document position of a Document and a new Document node |
| are disconnected, implementation-specific and preceding/following. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="documentPosition1" type="int"/> |
| <var name="documentPosition2" type="int"/> |
| <var name="documentPosition3" type="int"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="docElem" type="Element"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" qualifiedName='rootName' namespaceURI='rootNS' doctype="nullDocType"/> |
| <compareDocumentPosition var="documentPosition1" obj="doc" other="newDoc"/> |
| <assertEquals bitmask="57" actual="documentPosition1" expected="33" id="isImplSpecificDisconnected1" ignoreCase="false"/> |
| <compareDocumentPosition var="documentPosition2" obj="newDoc" other="doc"/> |
| <assertEquals bitmask="57" actual="documentPosition2" expected="33" id="isImplSpecificDisconnected2" ignoreCase="false"/> |
| <assertNotEquals bitmask="2" actual="documentPosition2" expected="documentPosition1" id="notBothPreceding" ignoreCase="false"/> |
| <assertNotEquals bitmask="4" actual="documentPosition2" expected="documentPosition1" id="notBothFollowing" ignoreCase="false"/> |
| <compareDocumentPosition var="documentPosition3" obj="doc" other="newDoc"/> |
| <assertEquals actual="documentPosition3" expected="documentPosition1" id="isConsistent" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition06.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition06"> |
| <metadata> |
| <title>nodecomparedocumentposition06</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the document position of a Document node contains and precedes |
| its DocumentElement, and the DocumentElement is contained and follows the Document node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="documentPositionDoc" type="int"/> |
| <var name="documentPositionDocElem" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <compareDocumentPosition var="documentPositionDoc" obj="doc" other="docElem"/> |
| <assertEquals actual="documentPositionDoc" expected="20" id="nodecomparedocumentpositionIsContainedFollowing06" ignoreCase="false"/> |
| <compareDocumentPosition var="documentPositionDocElem" obj="docElem" other="doc"/> |
| <assertEquals actual="documentPositionDocElem" expected="10" id="nodecomparedocumentpotionContainsPRECEDING06" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition07.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition07"> |
| <metadata> |
| <title>nodecomparedocumentposition07</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the document compared contains and precedes the new |
| newElement, and the newElement is contained and follows the document. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="documentPosition" type="int"/> |
| <var name="documentElementPosition" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createElementNS var="newElem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"br"'/> |
| <appendChild obj="docElem" var="appendedChild" newChild="newElem"/> |
| <compareDocumentPosition var="documentPosition" obj="doc" other="newElem"/> |
| <assertEquals actual="documentPosition" expected="20" id="nodecomparedocumentpositionIsContainedFollowing07" ignoreCase="false"/> |
| <compareDocumentPosition var="documentElementPosition" obj="newElem" other="doc"/> |
| <assertEquals actual="documentElementPosition" expected="10" id="nodecomparedocumentpositionContainedPRECEDING07" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition08.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition08"> |
| <metadata> |
| <title>nodecomparedocumentposition08</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the Document node contains and precedes an Element, |
| and the Element is contained and follows the Document node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="documentPosition" type="int"/> |
| <var name="elementPosition" type = "int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <compareDocumentPosition var="documentPosition" obj="doc" other="elem"/> |
| <assertEquals actual="documentPosition" expected="20" id="nodecomparedocumentpositionIsContainedFollowing08" ignoreCase="false"/> |
| <compareDocumentPosition var="elementPosition" obj="elem" other="doc"/> |
| <assertEquals actual="elementPosition" expected="10" id="nodecomparedocumentpositionContainsPRECEDING08" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition09.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition09"> |
| <metadata> |
| <title>nodecomparedocumentposition09</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the Element node is contained and follows the appended Document node, and |
| if the Document node contains and precedes the Element node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="documentPosition" type="int"/> |
| <var name="documentElementPosition" type = "int"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <createElementNS var="newElem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"br"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="newElem"/> |
| <compareDocumentPosition var="documentPosition" obj="doc" other="newElem"/> |
| <assertEquals actual="documentPosition" expected="20" id="nodecomparedocumentpositionIsContainedFollowing09" ignoreCase="false"/> |
| <compareDocumentPosition var="documentElementPosition" obj="newElem" other="doc"/> |
| <assertEquals actual="documentElementPosition" expected="10" id="nodecomparedocumentpositionContainsPRECEDING09" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition10.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition10"> |
| <metadata> |
| <title>nodecomparedocumentposition10</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the document node precedes and contains its default Attr node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="dir" type="Attr"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="attrPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="dir" obj="elem" name='"dir"'/> |
| <compareDocumentPosition var="attrPosition" obj="dir" other="doc"/> |
| <assertEquals actual="attrPosition" expected="10" id="nodecomparedocumentpositionPRECEDINGContains10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition11.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition11"> |
| <metadata> |
| <title>nodecomparedocumentposition11</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the Document node precedes and contains the Attr node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="documentPosition" type="int"/> |
| <var name="attrPosition" type ="int"/> |
| <var name="replacedAttr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <createAttributeNS var="newAttr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <setAttributeNodeNS obj="elem" var="replacedAttr" newAttr="newAttr"/> |
| <compareDocumentPosition var="attrPosition" obj="newAttr" other="doc"/> |
| <assertEquals actual="attrPosition" expected="10" id="nodecomparedocumentpositionPRECEDINGContains11" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition12.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition12"> |
| <metadata> |
| <title>nodecomparedocumentposition12</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if a new ProcessingInstruction node is contained and follows the |
| Document node, and that the Document node contains and precedes the ProcessingInstruction node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="documentPosition" type="int"/> |
| <var name="piPosition" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createProcessingInstruction var="pi" obj="doc" data='"PIDATA"' target='"PITarget"'/> |
| <appendChild obj="doc" var="appendedChild" newChild="pi"/> |
| <compareDocumentPosition var="documentPosition" obj="doc" other="pi"/> |
| <assertEquals actual="documentPosition" expected="20" id="nodecomparedocumentpositionIsContainedFollowing12" ignoreCase="false"/> |
| <compareDocumentPosition var="piPosition" obj="pi" other="doc"/> |
| <assertEquals actual="piPosition" expected="10" id="nodecomparedocumentpositionContainsPRECEDING12" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition13.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition13"> |
| <metadata> |
| <title>nodecomparedocumentposition13</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the Document node contains and precedes the new Comment node, |
| and if the Comment node is contained and follows the Document node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="comment" type="Comment"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="documentPosition" type="int"/> |
| <var name="commentPosition" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createComment var="comment" obj="doc" data='"Another Comment"'/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <appendChild obj="elem" var="appendedChild" newChild="comment"/> |
| <compareDocumentPosition var="documentPosition" obj="doc" other="comment"/> |
| <assertEquals actual="documentPosition" expected="20" id="nodecomparedocumentpositionIsContainedFollowing13" ignoreCase="false"/> |
| <compareDocumentPosition var="commentPosition" obj="comment" other="doc"/> |
| <assertEquals actual="commentPosition" expected="10" id="nodecomparedocumentpositionContainsPRECEDING13" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition14.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition14"> |
| <metadata> |
| <title>nodecomparedocumentposition14</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the DocumentFragment node contains and precedes an Element |
| node appended to it, and that the Element node is contained and follows the DocumentFragment node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="docElem" type="Element"/> |
| <var name="docFragChild" type="Node"/> |
| <var name="docFragPosition" type="int"/> |
| <var name="docFragChildPosition" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="docElem" /> |
| <firstChild var="docFragChild" obj="docFrag" interface="Node"/> |
| <compareDocumentPosition var="docFragPosition" obj="docFrag" other="docFragChild"/> |
| <assertEquals actual="docFragPosition" expected="20" id="nodecomparedocumentpositionContainsPRECEDING14" ignoreCase="false"/> |
| <compareDocumentPosition var="docFragChildPosition" obj="docFragChild" other="docFrag"/> |
| <assertEquals actual="docFragChildPosition" expected="10" id="nodecomparedocumentpositionIsContainedFollowing14" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition15.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition15"> |
| <metadata> |
| <title>nodecomparedocumentposition15</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the Element node precedes and contains its Attr child, and that the Attr child |
| is contained and follows the Element node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="docElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="docFragChild" type="Node"/> |
| <var name="attrPosition" type="int"/> |
| <var name="docFragChildPosition" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="attrNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <setAttributeNodeNS obj="docElem" var="attrNode" newAttr="attr" /> |
| <appendChild obj="docFrag" var="appendedChild" newChild="docElem" /> |
| <firstChild var="docFragChild" obj="docFrag" interface="Node"/> |
| <compareDocumentPosition var="docFragChildPosition" obj="docFragChild" other="attr"/> |
| <assertEquals actual="docFragChildPosition" expected="20" id="nodecomparedocumentpositionIsContainedFollows15" ignoreCase="false"/> |
| <compareDocumentPosition var="attrPosition" obj="attr" other="docFragChild"/> |
| <assertEquals actual="attrPosition" expected="10" id="nodecomparedocumentpositionPRECEEDINGContains15" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition16.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition16"> |
| <metadata> |
| <title>nodecomparedocumentposition16</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the document position of a DocumentFragment node compared with |
| a cloned Attr node is disconnected and implementation specific, and that the order between these two |
| nodes is preserved. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrCloned" type="Attr"/> |
| <var name="docFragPosition" type="int"/> |
| <var name="position1" type="int"/> |
| <var name="position2" type="int"/> |
| <var name="position3" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <cloneNode var="attrCloned" obj="attr" deep="true"/> |
| <compareDocumentPosition var="position1" obj="docFrag" other="attrCloned"/> |
| <!-- bitmask blocks out preceding and following bits --> |
| <assertEquals bitmask="57" actual="position1" expected="33" id="isImplSpecificDisconnected1" ignoreCase="false"/> |
| <compareDocumentPosition var="position2" obj="attrCloned" other="docFrag"/> |
| <assertNotEquals bitmask="2" actual="position2" expected="position1" id="notBothPreceding" ignoreCase="false"/> |
| <assertNotEquals bitmask="4" actual="position2" expected="position1" id="notBothFollowing" ignoreCase="false"/> |
| <assertEquals bitmask="57" actual="position2" expected="33" id="isImplSpecificDisconnected2" ignoreCase="false"/> |
| <!-- returned value should be consistent between invocations --> |
| <compareDocumentPosition var="position3" obj="docFrag" other="attrCloned"/> |
| <assertEquals actual="position3" expected="position1" id="isConsistent" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition17.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition17"> |
| <metadata> |
| <title>nodecomparedocumentposition17</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the document position of the first ProcessingInstruction node compared to |
| this second newly apended ProcessingInstruction node is PRECEDING, and FOLLOWING vice versa. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="pi1" type="ProcessingInstruction"/> |
| <var name="pi2" type="ProcessingInstruction"/> |
| <var name="pi1Position" type="int"/> |
| <var name="pi2Position" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createProcessingInstruction var="pi1" obj="doc" target='"PI1"' data='""'/> |
| <createProcessingInstruction var="pi2" obj="doc" target='"PI2"' data='""'/> |
| <appendChild obj="doc" var="appendedChild" newChild="pi1"/> |
| <appendChild obj="doc" var="appendedChild" newChild="pi2"/> |
| <compareDocumentPosition var="pi1Position" obj="pi1" other="pi2"/> |
| <assertEquals actual="pi1Position" expected="4" id="nodecomparedocumentpositionFollowing17" ignoreCase="false"/> |
| <compareDocumentPosition var="pi2Position" obj="pi2" other="pi1"/> |
| <assertEquals actual="pi2Position" expected="2" id="nodecomparedocumentpositionPRECEDING17" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition18.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition18"> |
| <metadata> |
| <title>nodecomparedocumentposition18</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the document position of the first new Text node compared to the |
| second text node is PRECEDING and is FOLLOWING vice versa. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="txt1" type="Text"/> |
| <var name="txt2" type="Text"/> |
| <var name="txt1Position" type="int"/> |
| <var name="txt2Position" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createTextNode var="txt1" obj="doc" data='"T1"'/> |
| <createTextNode var="txt2" obj="doc" data='"T2"'/> |
| <appendChild obj="docElem" var="appendedChild" newChild="txt1"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="txt2"/> |
| <compareDocumentPosition var="txt1Position" obj="txt1" other="txt2"/> |
| <assertEquals actual="txt1Position" expected="4" id="nodecomparedocumentpositionFollowing18" ignoreCase="false"/> |
| <compareDocumentPosition var="txt2Position" obj="txt2" other="txt1"/> |
| <assertEquals actual="txt2Position" expected="2" id="nodecomparedocumentpositionPRECEDING18" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition19.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition19"> |
| <metadata> |
| <title>nodecomparedocumentposition19</title> |
| <creator>IBM</creator> |
| <description> |
| The method compareDocumentPosition compares a node with this node with regard to their position in the |
| document and according to the document order. |
| Using compareDocumentPosition check if the document position of the first CDATASection node |
| of the second element whose localName is name compared with the second CDATASection node |
| is PRECEDING and is FOLLOWING vice versa. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <implementationAttribute name="coalescing" value="false"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elemStrong" type="Element"/> |
| <var name="cdata1" type="CDATASection"/> |
| <var name="cdata2" type="CDATASection"/> |
| <var name="aNode" type="Node"/> |
| <var name="cdata1Position" type="int"/> |
| <var name="cdata2Position" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="elemList" obj="doc" namespaceURI='"*"' localName='"strong"' interface="Document"/> |
| <item var="elemStrong" obj="elemList" index="1" interface="NodeList"/> |
| <lastChild var="cdata2" obj="elemStrong" interface="Node"/> |
| <previousSibling var="aNode" obj="cdata2" interface="Node"/> |
| <previousSibling var="cdata1" obj="aNode" interface="Node"/> |
| <compareDocumentPosition var="cdata1Position" obj="cdata1" other="cdata2"/> |
| <assertEquals actual="cdata1Position" expected="4" id="nodecomparedocumentposition19_cdata2Follows" ignoreCase="false"/> |
| <compareDocumentPosition var="cdata2Position" obj="cdata2" other="cdata1"/> |
| <assertEquals actual="cdata2Position" expected="2" id="nodecomparedocumentposition_cdata1Precedes" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition20.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition20"> |
| <metadata> |
| <title>nodecomparedocumentposition20</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the document position of the first Text node |
| of the second element whose localName is name compared with the next CDATASection node |
| is PRECEDING and FOLLOWING vice versa. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <implementationAttribute name="coalescing" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elemName" type="Element"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="txt" type="Text"/> |
| <var name="txtPosition" type="int"/> |
| <var name="cdataPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elemName" obj="elemList" index="1" interface="NodeList"/> |
| <firstChild var="txt" obj="elemName" interface="Node"/> |
| <lastChild var="cdata" obj="elemName" interface="Node"/> |
| <compareDocumentPosition var="txtPosition" obj="txt" other="cdata"/> |
| <assertEquals actual="txtPosition" expected="4" id="nodecomparedocumentpositionFollowingg20" ignoreCase="false"/> |
| <compareDocumentPosition var="cdataPosition" obj="cdata" other="txt"/> |
| <assertEquals actual="cdataPosition" expected="2" id="nodecomparedocumentpositionPRECEDING20" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition21.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition21"> |
| <metadata> |
| <title>nodecomparedocumentposition21</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check the document position of the text node of the fist and second elements |
| whose localName is name. The first text node should return FOLLOWING and the second text node should |
| return PRECEDING when compareDocumentPosition is invoked with the other node as a parameter. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <implementationAttribute name="coalescing" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elemName1" type="Element"/> |
| <var name="elemName2" type="Element"/> |
| <var name="txt1" type="Text"/> |
| <var name="txt2" type="Text"/> |
| <var name="txt1Position" type="int"/> |
| <var name="txt2Position" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elemName1" obj="elemList" index="0" interface="NodeList"/> |
| <item var="elemName2" obj="elemList" index="1" interface="NodeList"/> |
| <firstChild var="txt1" obj="elemName1" interface="Node"/> |
| <firstChild var="txt2" obj="elemName2" interface="Node"/> |
| <compareDocumentPosition var="txt1Position" obj="txt1" other="txt2"/> |
| <assertEquals actual="txt1Position" expected="4" id="nodecomparedocumentpositionFollowing21" ignoreCase="false"/> |
| <compareDocumentPosition var="txt2Position" obj="txt2" other="txt1"/> |
| <assertEquals actual="txt2Position" expected="2" id="nodecomparedocumentpositionPRECEDING21" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition22.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition22"> |
| <metadata> |
| <title>nodecomparedocumentposition22</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the Entity node precedes the Notation node and the Notation |
| node follows the Entity node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <implementationAttribute name="coalescing" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="notation" type="Notation"/> |
| <var name="entityPosition" type="int"/> |
| <var name="notationPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <notations var="notationsMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"alpha"'/> |
| <getNamedItem var="notation" obj="notationsMap" name='"notation1"'/> |
| <compareDocumentPosition var="entityPosition" obj="entity" other="notation"/> |
| <assertEquals actual="entityPosition" expected="4" id="nodecomparedocumentpositionFollowing22" ignoreCase="false"/> |
| <compareDocumentPosition var="notationPosition" obj="notation" other="entity"/> |
| <assertEquals actual="notationPosition" expected="2" id="nodecomparedocumentpositionPRECEDING22" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition23.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition23"> |
| <metadata> |
| <title>nodecomparedocumentposition23</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the document position of an Entity node compared to another |
| Entity node following it in DocumentType is implementation specific. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="entity2" type="Entity"/> |
| <var name="position1" type="int"/> |
| <var name="position2" type="int"/> |
| <var name="position3" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"alpha"'/> |
| <getNamedItem var="entity2" obj="entitiesMap" name='"delta"'/> |
| <compareDocumentPosition var="position1" obj="entity" other="entity2"/> |
| <!-- bitmask blocks out preceding and following bits --> |
| <assertEquals bitmask="57" actual="position1" expected="32" id="isImplSpecificDisconnected1" ignoreCase="false"/> |
| <compareDocumentPosition var="position2" obj="entity2" other="entity"/> |
| <assertNotEquals bitmask="2" actual="position2" expected="position1" id="notBothPreceding" ignoreCase="false"/> |
| <assertNotEquals bitmask="4" actual="position2" expected="position1" id="notBothFollowing" ignoreCase="false"/> |
| <assertEquals bitmask="57" actual="position2" expected="32" id="isImplSpecificDisconnected2" ignoreCase="false"/> |
| <!-- returned value should be consistent between invocations --> |
| <compareDocumentPosition var="position3" obj="entity" other="entity2"/> |
| <assertEquals actual="position3" expected="position1" id="isConsistent" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition24.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition24"> |
| <metadata> |
| <title>nodecomparedocumentposition24</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the return value of document position of a Notation node compared to another |
| that is the same is not flagged. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notaionsMap" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="notation2" type="Notation"/> |
| <var name="notationPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notaionsMap" obj="docType"/> |
| <getNamedItem var="notation" obj="notaionsMap" name='"notation1"'/> |
| <getNamedItem var="notation2" obj="notaionsMap" name='"notation1"'/> |
| <compareDocumentPosition var="notationPosition" obj="notation" other="notation2"/> |
| <assertEquals actual="notationPosition" expected="0" id="nodecomparedocumentposition24" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition25.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition25"> |
| <metadata> |
| <title>nodecomparedocumentposition25</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the EntityReference or Text node is contained and follows its |
| parent Element node, and that the Element node contains and precedes the |
| EntityReference or Text node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elemName" type="Element"/> |
| <var name="entRef" type="Node"/> |
| <var name="elementPosition" type="int"/> |
| <var name="entRefPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"var"' interface="Document"/> |
| <item var="elemName" obj="elemList" index="2" interface="NodeList"/> |
| <firstChild obj="elemName" var="entRef" interface="Node"/> |
| <compareDocumentPosition var="elementPosition" obj="elemName" other="entRef"/> |
| <assertEquals actual="elementPosition" expected="20" id="nodecomparedocumentpositionIsContainedFollowing25" ignoreCase="false"/> |
| <compareDocumentPosition var="entRefPosition" obj="entRef" other="elemName"/> |
| <assertEquals actual="entRefPosition" expected="10" id="nodecomparedocumentpositionContainsPRECEDING25" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition26.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition26"> |
| <metadata> |
| <title>nodecomparedocumentposition26</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check if the EntityReference node contains and precedes it's first |
| childElement, and that the childElement is contained and follows the EntityReference node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="varList" type="NodeList"/> |
| <var name="varElem" type="Element"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entRefChild1" type="Element"/> |
| <var name="entRefPosition" type="int"/> |
| <var name="entRefChild1Position" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <if> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <getElementsByTagName var="varList" obj="doc" tagname='"var"' interface="Document"/> |
| <item var="varElem" obj="varList" index="2" interface="NodeList"/> |
| <assertNotNull actual="varElem" id="varElemNotNull"/> |
| <firstChild var="entRef" obj="varElem" interface="Node"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <else> |
| <createEntityReference name='"ent4"' obj="doc" var="entRef"/> |
| </else> |
| </if> |
| <firstChild var="entRefChild1" obj="entRef" interface="Node"/> |
| <assertNotNull actual="entRefChild1" id="entRefChild1NotNull"/> |
| <compareDocumentPosition var="entRefPosition" obj="entRef" other="entRefChild1"/> |
| <assertEquals actual="entRefPosition" expected="20" id="nodecomparedocumentpositionIsContainedFollowing26" ignoreCase="false"/> |
| <compareDocumentPosition var="entRefChild1Position" obj="entRefChild1" other="entRef"/> |
| <assertEquals actual="entRefChild1Position" expected="10" id="nodecomparedocumentpositionContainsPRECEDING26" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition27.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition27"> |
| <metadata> |
| <title>nodecomparedocumentposition27</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if the EntityReference node contains and precedes it's last |
| childElement, and that this childElement is contained and follows the EntityReference node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="varList" type="NodeList"/> |
| <var name="varElem" type="Element"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entRefChild1" type="ProcessingInstruction"/> |
| <var name="entRefPosition" type="int"/> |
| <var name="entRefChild1Position" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <if> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <getElementsByTagName var="varList" obj="doc" tagname='"var"' interface="Document"/> |
| <item var="varElem" obj="varList" index="2" interface="NodeList"/> |
| <assertNotNull actual="varElem" id="varElemNotNull"/> |
| <firstChild var="entRef" obj="varElem" interface="Node"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <else> |
| <createEntityReference name='"ent4"' obj="doc" var="entRef"/> |
| </else> |
| </if> |
| <lastChild obj="entRef" var="entRefChild1" interface="Node"/> |
| <assertNotNull actual="entRefChild1" id="entRefChild1NotNull"/> |
| <compareDocumentPosition var="entRefPosition" obj="entRef" other="entRefChild1"/> |
| <assertEquals actual="entRefPosition" expected="20" id="nodecomparedocumentpositionIsContainedFollowing27" ignoreCase="false"/> |
| <compareDocumentPosition var="entRefChild1Position" obj="entRefChild1" other="entRef"/> |
| <assertEquals actual="entRefChild1Position" expected="10" id="nodecomparedocumentpositionContainsPRECEDING" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition28.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition28"> |
| <metadata> |
| <title>nodecomparedocumentposition28</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition check the document position of the EntityReference node ent4's |
| first child and last child. Invoke compareDocumentPositon on first child with last child as a parameter |
| should return FOLLOWING, and should return PRECEDING vice versa. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="varList" type="NodeList"/> |
| <var name="varElem" type="Element"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="entRefChild1" type="Element"/> |
| <var name="entRefChild2" type="ProcessingInstruction"/> |
| <var name="entRefChild1Position" type="int"/> |
| <var name="entRefChild2Position" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <if> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <getElementsByTagName var="varList" obj="doc" tagname='"var"' interface="Document"/> |
| <item var="varElem" obj="varList" index="2" interface="NodeList"/> |
| <assertNotNull actual="varElem" id="varElemNotNull"/> |
| <firstChild var="entRef" obj="varElem" interface="Node"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <else> |
| <createEntityReference name='"ent4"' obj="doc" var="entRef"/> |
| </else> |
| </if> |
| <firstChild obj="entRef" var="entRefChild1" interface="Node"/> |
| <assertNotNull actual="entRefChild1" id="entRefChild1NotNull"/> |
| <lastChild obj="entRef" var="entRefChild2" interface="Node"/> |
| <assertNotNull actual="entRefChild2" id="entRefChild2NotNull"/> |
| <compareDocumentPosition var="entRefChild1Position" obj="entRefChild1" other="entRefChild2"/> |
| <assertEquals actual="entRefChild1Position" expected="4" id="nodecomparedocumentpositionFollowing28" ignoreCase="false"/> |
| <compareDocumentPosition var="entRefChild2Position" obj="entRefChild2" other="entRefChild1"/> |
| <assertEquals actual="entRefChild2Position" expected="2" id="nodecomparedocumentpositionPRECEDING28" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition29.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition29"> |
| <metadata> |
| <title>nodecomparedocumentposition29</title> |
| <creator>IBM</creator> |
| <description> |
| Create two entity reference nodes. Using compareDocumentPosition to check if the child of the first Entity |
| Ref node precedes the child of the second Entity Ref node, and that the child of the second Entity Ref node |
| follows the child of the first Entity Ref node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-20</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="entRef1" type="EntityReference"/> |
| <var name="entRef2" type="EntityReference"/> |
| <var name="entRefChild1" type="Element"/> |
| <var name="entRefChild2" type="ProcessingInstruction"/> |
| <var name="entRefChild1Position" type="int"/> |
| <var name="entRefChild2Position" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEntityReference name='"ent4"' obj="doc" var="entRef1"/> |
| <createEntityReference name='"ent4"' obj="doc" var="entRef2"/> |
| <documentElement var="docElem" obj="doc"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="entRef1"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="entRef2"/> |
| <firstChild obj="entRef1" var="entRefChild1" interface="Node"/> |
| <assertNotNull actual="entRefChild1" id="entRefChild1NotNull"/> |
| <lastChild obj="entRef2" var="entRefChild2" interface="Node"/> |
| <assertNotNull actual="entRefChild2" id="entRefChild2NotNull"/> |
| <compareDocumentPosition var="entRefChild1Position" obj="entRefChild1" other="entRefChild2"/> |
| <assertEquals actual="entRefChild1Position" expected="4" id="nodecomparedocumentpositionFollowing29" ignoreCase="false"/> |
| <compareDocumentPosition var="entRefChild2Position" obj="entRefChild2" other="entRefChild1"/> |
| <assertEquals actual="entRefChild2Position" expected="2" id="nodecomparedocumentpositionPRECEDING29" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition30.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition30"> |
| <metadata> |
| <title>nodecomparedocumentposition30</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareTreePosition check if comparedocumentposition invoked on the first name with |
| the first position node as a parameter returns FOLLOWING. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-03-03</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <var name="positionList" type="NodeList"/> |
| <var name="strong" type="Element"/> |
| <var name="code" type="Element"/> |
| <var name="namePosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="nameList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="strong" obj="nameList" index="0" interface="NodeList"/> |
| <getElementsByTagName var="positionList" obj="doc" tagname='"code"' interface="Document"/> |
| <item var="code" obj="positionList" index="0" interface="NodeList"/> |
| <compareDocumentPosition var="namePosition" obj="code" other="strong"/> |
| <assertEquals actual="namePosition" expected="2" id="nodecomparedocumentpositionFollowing30" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition31.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition31"> |
| <metadata> |
| <title>nodecomparedocumentposition31</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if invoking the method on the first name node with |
| a new node appended to the second position node as a parameter is FOLLOWING, and is PRECEDING vice versa |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <var name="positionList" type="NodeList"/> |
| <var name="strong" type="Element"/> |
| <var name="code" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="namePosition" type="int"/> |
| <var name="elemPosition" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="nameList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="strong" obj="nameList" index="0" interface="NodeList"/> |
| <getElementsByTagName var="positionList" obj="doc" tagname='"code"' interface="Document"/> |
| <item var="code" obj="positionList" index="1" interface="NodeList"/> |
| <createElementNS var="newElem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"br"'/> |
| <appendChild obj="code" var="appendedChild" newChild="newElem"/> |
| <compareDocumentPosition var="namePosition" obj="strong" other="newElem"/> |
| <assertEquals actual="namePosition" expected="4" id="nodecomparedocumentpositionFollowing31" ignoreCase="false"/> |
| <compareDocumentPosition var="elemPosition" obj="newElem" other="strong"/> |
| <assertEquals actual="elemPosition" expected="2" id="nodecomparedocumentpositionPRECEDING31" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition32.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition32"> |
| <metadata> |
| <title>nodecomparedocumentposition32</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if the document position returned by comparing the first name with |
| a first position node of another document reference and adopted by the first as a parameter is FOLLOWING. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="nameList" type="NodeList"/> |
| <var name="positionList" type="NodeList"/> |
| <var name="strong" type="Element"/> |
| <var name="code" type="Element"/> |
| <var name="documentPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <assign var="doc2" value="doc"/> |
| <getElementsByTagName var="nameList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="strong" obj="nameList" index="0" interface="NodeList"/> |
| <getElementsByTagName var="positionList" obj="doc2" tagname='"code"' interface="Document"/> |
| <item var="code" obj="positionList" index="0" interface="NodeList"/> |
| <compareDocumentPosition var="documentPosition" obj="strong" other="code"/> |
| <assertEquals actual="documentPosition" expected="4" id="nodecomparedocumentpositionFollowing32" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition33.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition33"> |
| <metadata> |
| <title>nodecomparedocumentposition33</title> |
| <creator>IBM</creator> |
| <description> |
| Create a new Element node, add a new atttribute node to it. Compare the position |
| of the Element and the Document. This should return disconnected, implementation specific, and that |
| the order of these two nodes is preserved. |
| Also compare the position of the Element node with respect to the Attr node and this should |
| be PRECEDING and contains, and the Attr node follows and is contained by the Element node |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="position1" type="int"/> |
| <var name="position2" type="int"/> |
| <var name="position3" type="int"/> |
| <var name="position4" type="int"/> |
| <var name="position5" type="int"/> |
| <var name="replacedAttr" type="Attr"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"br"'/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <setAttributeNodeNS obj="elem" var="replacedAttr" newAttr="attr"/> |
| <compareDocumentPosition var="position4" obj="elem" other="attr"/> |
| <assertEquals actual="position4" expected="20" id="nodecomparedocumentposition3FollowingisContained33" ignoreCase="false"/> |
| <compareDocumentPosition var="position5" obj="attr" other="elem"/> |
| <assertEquals actual="position5" expected="10" id="nodecomparedocumentposition4ContainsPRECEDING33" ignoreCase="false"/> |
| <compareDocumentPosition var="position1" obj="doc" other="elem"/> |
| <!-- bitmask blocks out preceding and following bits --> |
| <assertEquals bitmask="57" actual="position1" expected="33" id="isImplSpecificDisconnected1" ignoreCase="false"/> |
| <compareDocumentPosition var="position2" obj="elem" other="doc"/> |
| <assertNotEquals bitmask="2" actual="position2" expected="position1" id="notBothPreceding" ignoreCase="false"/> |
| <assertNotEquals bitmask="4" actual="position2" expected="position1" id="notBothFollowing" ignoreCase="false"/> |
| <assertEquals bitmask="57" actual="position2" expected="33" id="isImplSpecificDisconnected2" ignoreCase="false"/> |
| <!-- returned value should be consistent between invocations --> |
| <compareDocumentPosition var="position3" obj="doc" other="elem"/> |
| <assertEquals actual="position3" expected="position1" id="isConsistent" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition34.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition34"> |
| <metadata> |
| <title>nodecomparedocumentposition34</title> |
| <creator>IBM</creator> |
| <description> |
| Create a new Element node, add new Text, Element and Processing Instruction nodes to it. |
| Using compareDocumentPosition, compare the position of the Element with respect to the Text |
| and the Text with respect to the Processing Instruction. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemMain" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="elementToTxtPosition" type="int"/> |
| <var name="txtToPiPosition" type="int"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="elemMain" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"'/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"br"'/> |
| <createTextNode var="txt" obj="doc" data='"TEXT"'/> |
| <createProcessingInstruction var="pi" obj="doc" data='"PID"' target='"PIT"'/> |
| <appendChild obj="elemMain" var="appendedChild" newChild="txt"/> |
| <appendChild obj="elemMain" var="appendedChild" newChild="elem"/> |
| <appendChild obj="elemMain" var="appendedChild" newChild="pi"/> |
| <compareDocumentPosition var="elementToTxtPosition" obj="txt" other="elem"/> |
| <assertEquals actual="elementToTxtPosition" expected="4" id="nodecomparedocumentpositionFollowing34" ignoreCase="false"/> |
| <compareDocumentPosition var="txtToPiPosition" obj="pi" other="txt"/> |
| <assertEquals actual="txtToPiPosition" expected="2" id="nodecomparedocumentpositionPRECEDING34" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition35.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition35"> |
| <metadata> |
| <title>nodecomparedocumentposition35</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if the Element contains and precedes its default attribute |
| and that the attribute follows and iscontained by the Element |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elementPosition" type="int"/> |
| <var name="attrPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="elem" name='"dir"'/> |
| <compareDocumentPosition var="elementPosition" obj="elem" other="attr"/> |
| <assertEquals actual="elementPosition" expected="20" id="nodecomparedocumentpositionIsContainedFollowing35" ignoreCase="false"/> |
| <compareDocumentPosition var="attrPosition" obj="attr" other="elem"/> |
| <assertEquals actual="attrPosition" expected="10" id="nodecomparedocumentpositionPRECEDINGContains35" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition36.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition36"> |
| <metadata> |
| <title>nodecomparedocumentposition36</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if the document position of an Attribute compared with |
| the element that follows its parent as a parameter is FOLLOWING, and is PRECEDING |
| vice versa. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="elemListFollows" type="NodeList"/> |
| <var name="elemFollows" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrPosition" type="int"/> |
| <var name="elemFollowsPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="elem" name='"dir"'/> |
| <getElementsByTagName var="elemListFollows" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elemFollows" obj="elemListFollows" index="3" interface="NodeList"/> |
| <compareDocumentPosition var="attrPosition" obj="attr" other="elemFollows"/> |
| <assertEquals actual="attrPosition" expected="4" id="nodecomparedocumentpositionFollowing36" ignoreCase="false"/> |
| <compareDocumentPosition var="elemFollowsPosition" obj="elemFollows" other="attr"/> |
| <assertEquals actual="elemFollowsPosition" expected="2" id="nodecomparedocumentpositionPRECEEDING36" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition37.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition37"> |
| <metadata> |
| <title>nodecomparedocumentposition37</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if the document position of the first class attribute |
| of the element acronym when compared with the elements text content as a parameter is |
| is FOLLOWING, and is PRECEDING vice versa. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrPosition" type="int"/> |
| <var name="txtPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="elem" name='"class"'/> |
| <firstChild var="txt" obj="elem" interface="Node"/> |
| <compareDocumentPosition var="attrPosition" obj="attr" other="txt"/> |
| <assertEquals actual="attrPosition" expected="4" id="nodecomparetreepositionFollowing37" ignoreCase="false"/> |
| <compareDocumentPosition var="txtPosition" obj="txt" other="attr"/> |
| <assertEquals actual="txtPosition" expected="2" id="nodecomparetreepositionPRECEDING37" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition38.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition38"> |
| <metadata> |
| <title>nodecomparedocumentposition38</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if the class's attribute contains and precedes it's content, |
| and the content node is contained and follows the attribute node. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrPosition" type="int"/> |
| <var name="attrChildPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="elem" name='"class"'/> |
| <firstChild var="txt" obj="attr" interface="Node"/> |
| <compareDocumentPosition var="attrPosition" obj="attr" other="txt"/> |
| <assertEquals actual="attrPosition" expected="20" id="nodecomparedocumentpositionIsContainsFollowing38" ignoreCase="false"/> |
| <compareDocumentPosition var="attrChildPosition" obj="txt" other="attr"/> |
| <assertEquals actual="attrChildPosition" expected="10" id="nodecomparedocumentpositionContainsPRECEDING38" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition39.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition39"> |
| <metadata> |
| <title>nodecomparedocumentposition39</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if the document position of the class's attribute |
| when compared with the local1 attribute node is implementation_specific. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="attr1" type="Attr"/> |
| <var name="attr2" type="Attr"/> |
| <var name="attrPosition" type="int"/> |
| <var name="swappedPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr1" obj="elem" name='"class"'/> |
| <getAttributeNode var="attr2" obj="elem" name='"xsi:noNamespaceSchemaLocation"'/> |
| <compareDocumentPosition var="attrPosition" obj="attr1" other="attr2"/> |
| <assertEquals actual="attrPosition" expected="32" bitmask="32" id="isImplementationSpecific" ignoreCase="false"/> |
| <assertEquals actual="attrPosition" expected="0" bitmask="25" id="otherBitsZero" ignoreCase="false"/> |
| <assertNotEquals actual="attrPosition" expected="0" bitmask="6" id="eitherFollowingOrPreceding" ignoreCase="false"/> |
| <compareDocumentPosition var="swappedPosition" obj="attr2" other="attr1"/> |
| <assertNotEquals actual="attrPosition" expected="swappedPosition" bitmask="2" id="onlyOnePreceding" ignoreCase="false"/> |
| <assertNotEquals actual="attrPosition" expected="swappedPosition" bitmask="4" id="onlyOneFollowing" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodecomparedocumentposition40.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodecomparedocumentposition40"> |
| <metadata> |
| <title>nodecomparedocumentposition40</title> |
| <creator>IBM</creator> |
| <description> |
| Using compareDocumentPosition to check if the document position of the class's attribute |
| when compared with a new attribute node is implementation_specific |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-21</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-compareDocumentPosition"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="attr1" type="Attr"/> |
| <var name="attr2" type="Attr"/> |
| <var name="attrPosition" type="int"/> |
| <var name="swappedPosition" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr1" obj="elem" name='"class"'/> |
| <setAttributeNS obj="elem" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"' value='"FR-fr"'/> |
| <getAttributeNode var="attr2" obj="elem" name='"xml:lang"'/> |
| <compareDocumentPosition var="attrPosition" obj="attr1" other="attr2"/> |
| <assertEquals actual="attrPosition" expected="32" bitmask="32" id="isImplementationSpecific" ignoreCase="false"/> |
| <assertEquals actual="attrPosition" expected="0" bitmask="25" id="otherBitsZero" ignoreCase="false"/> |
| <assertNotEquals actual="attrPosition" expected="0" bitmask="6" id="eitherFollowingOrPreceding" ignoreCase="false"/> |
| <compareDocumentPosition var="swappedPosition" obj="attr2" other="attr1"/> |
| <assertNotEquals actual="attrPosition" expected="swappedPosition" bitmask="2" id="onlyOnePreceding" ignoreCase="false"/> |
| <assertNotEquals actual="attrPosition" expected="swappedPosition" bitmask="4" id="onlyOneFollowing" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri01.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri01"> |
| <metadata> |
| <title>nodegetbaseuri01</title> |
| <creator>IBM</creator> |
| <description> |
| Call Node.getBaseURI() on a test document. Should be not-null and same as Document.getDocumentURI(). |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Document"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="documentURI" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <baseURI var="baseURI" obj="doc" interface="Node"/> |
| <assertURIEquals actual="baseURI" name='"barfoo"' isAbsolute="true" id="notNull"/> |
| <documentURI var="documentURI" obj="doc"/> |
| <assertEquals actual="baseURI" expected="documentURI" ignoreCase="false" id="sameAsDocumentURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri02.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri02"> |
| <metadata> |
| <title>nodegetbaseuri02</title> |
| <creator>IBM</creator> |
| <description> |
| Using getBaseURI check if the baseURI attribute of a new Document node is null |
| and if affected by changes in Document.documentURI. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Document"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="docElem" type="Element"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='rootNS' qualifiedName='rootName' doctype="nullDocType"/> |
| <baseURI var="baseURI" obj="newDoc" interface="Node"/> |
| <assertNull actual="baseURI" id="baseURIIsNull"/> |
| <documentURI obj="newDoc" value='"http://www.example.com/sample.xml"'/> |
| <baseURI var="baseURI" obj="newDoc" interface="Node"/> |
| <assertEquals expected='"http://www.example.com/sample.xml"' actual="baseURI" ignoreCase="true" id="baseURISameAsDocURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri03.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri03"> |
| <metadata> |
| <title>nodegetbaseuri03</title> |
| <creator>IBM</creator> |
| <description> |
| Check that Node.baseURI is null for a DocumentType as defined in the Infoset Mapping (Appendix C). |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2DocumentType"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="baseURI" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <baseURI var="baseURI" obj="docType" interface="Node"/> |
| <assertNull actual="baseURI" id="nodegetbaseuri03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri04.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri04"> |
| <metadata> |
| <title>nodegetbaseuri04</title> |
| <creator>IBM</creator> |
| <description> |
| Node.baseURI for a document element without an xml:base attribute should be same as Document.documentURI. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Document"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="documentURI" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <baseURI var="baseURI" obj="docElem" interface="Node"/> |
| <assertURIEquals actual="baseURI" isAbsolute="true" name='"barfoo"' id="baseURI"/> |
| <documentURI var="documentURI" obj="doc"/> |
| <assertEquals actual="baseURI" expected="documentURI" ignoreCase="false" id="baseURIEqualsDocURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri05.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri05"> |
| <metadata> |
| <title>nodegetbaseuri05</title> |
| <creator>IBM</creator> |
| <description> |
| Using getBaseURI check if the baseURI attribute of this DocumentElement is http://www.w3.org/DOM/L3Test. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Element"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="baseURI" type="DOMString"/> |
| <load var="doc" href="barfoo_base" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <baseURI var="baseURI" obj="docElem" interface="Node"/> |
| <assertEquals actual="baseURI" expected='"http://www.w3.org/DOM/L3Test"' id="nodegetbaseuri05" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri06.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri06"> |
| <metadata> |
| <title>nodegetbaseuri06</title> |
| <creator>IBM</creator> |
| <description> |
| TODO Clarification: Create a new Element in this document. Since its baseURI should be the baseURI of |
| the Document Entity which I assume is not null, using getBaseURI check if the baseURI |
| attribute of this Element node is not null.??? |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Element"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newElement" type="Element"/> |
| <var name="baseURI" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <createElementNS var="newElement" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"br"'/> |
| <baseURI var="baseURI" obj="doc" interface="Node"/> |
| <assertNotNull actual="baseURI" id="nodegetbaseuri06"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri07.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri07"> |
| <metadata> |
| <title>nodegetbaseuri07</title> |
| <creator>IBM</creator> |
| <description> |
| Append a created element to a document and check that its baseURI |
| is inherited from its parent. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Element"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newElement" type="Element"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="appended" type="Node"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="bodyElem" type="Element"/> |
| <var name="htmlNS" type="DOMString" value='"http://www.w3.org/1999/xhtml"'/> |
| <load var="doc" href="barfoo_base" willBeModified="true"/> |
| <getElementsByTagName var="bodyList" obj="doc" |
| tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <createElementNS var="newElement" obj="doc" namespaceURI='htmlNS' qualifiedName='"meta"'/> |
| <setAttribute obj="newElement" name='"content"' value='"text/xml"'/> |
| <appendChild obj="bodyElem" var="appended" newChild="newElement"/> |
| <baseURI var="baseURI" obj="newElement" interface="Node"/> |
| <assertEquals actual="baseURI" expected='"http://www.w3.org/DOM/EmployeeID"' id="nodegetbaseuri07" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri09.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri09"> |
| <metadata> |
| <title>nodegetbaseuri09</title> |
| <creator>IBM</creator> |
| <description> |
| Get the baseURI value on an element with an explicit xml:base attribute. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Element"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="bodyElem" type="Element"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="baseURI" type="DOMString"/> |
| <load var="doc" href="barfoo_base" willBeModified="false"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <baseURI var="baseURI" obj="bodyElem" interface="Node"/> |
| <assertEquals actual="baseURI" expected='"http://www.w3.org/DOM/EmployeeID"' id="nodegetbaseuri09" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri10.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri10"> |
| <metadata> |
| <title>nodegetbaseuri10</title> |
| <creator>IBM</creator> |
| <description> |
| Append as a child of this documentElement a new Processing Instruction. Using getBaseURI |
| check if the baseURI attribute of the new Processing Instruction node is "'http://www.w3.org/DOM/L3Test". |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2ProcessingInstruction"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="newPI" type="ProcessingInstruction"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="barfoo_base" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createProcessingInstruction var="newPI" obj="doc" target='"TARGET"' data='"DATA"'/> |
| <appendChild obj="docElem" var="appendedChild" newChild="newPI"/> |
| <baseURI var="baseURI" obj="newPI" interface="Node"/> |
| <assertEquals actual="baseURI" expected='"http://www.w3.org/DOM/L3Test"' id="nodegetbaseuri10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri11.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri11"> |
| <metadata> |
| <title>nodegetbaseuri11</title> |
| <creator>IBM</creator> |
| <description> |
| Import a new Processing Instruction of a new Document after the document element. Using getBaseURI |
| check if the baseURI attribute of the new Processing Instruction node is the same as Document.documentURI. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2ProcessingInstruction"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newPI" type="ProcessingInstruction"/> |
| <var name="imported" type="ProcessingInstruction"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="docURI" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="barfoo_base" willBeModified="true"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"html"' doctype="nullDocType"/> |
| <createProcessingInstruction var="newPI" obj="newDoc" target='"TARGET"' data='"DATA"'/> |
| <importNode var="imported" obj="doc" importedNode="newPI" deep="true"/> |
| <appendChild obj="doc" var="appendedChild" newChild="imported"/> |
| <baseURI var="baseURI" obj="imported" interface="Node"/> |
| <assertURIEquals actual="baseURI" isAbsolute="true" name='"barfoo_base"' id="equalsBarfooBase"/> |
| <documentURI var="docURI" obj="doc"/> |
| <assertEquals actual="baseURI" expected="docURI" ignoreCase="false" id="equalsDocURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri12.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri12"> |
| <metadata> |
| <title>nodegetbaseuri12</title> |
| <creator>IBM</creator> |
| <description> |
| Using getBaseURI verify if the entity epsilon is absolute |
| and matches the URL of the document entity. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Entity"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="baseURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"epsilon"'/> |
| <baseURI var="baseURI" obj="entity" interface="Node"/> |
| <assertURIEquals actual="baseURI" id="entityBase" isAbsolute="true" name='"hc_staff"'/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri13.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri13"> |
| <metadata> |
| <title>nodegetbaseuri13</title> |
| <creator>IBM</creator> |
| <description> |
| Using getBaseURI verify if the notation defined in an internal subset |
| is the base URI of the document. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Notation"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="docURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notationsMap" obj="docType"/> |
| <getNamedItem var="notation" obj="notationsMap" name='"notation1"'/> |
| <baseURI var="baseURI" obj="notation" interface="Node"/> |
| <documentURI var="docURI" obj="doc"/> |
| <assertEquals actual="baseURI" expected="docURI" ignoreCase="false" id="sameAsDocURI"/> |
| <assertURIEquals actual="baseURI" id="entityBase" isAbsolute="true" name='"hc_staff"'/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri14.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri14"> |
| <metadata> |
| <title>nodegetbaseuri14</title> |
| <creator>IBM</creator> |
| <description> |
| Using getBaseURI verify if the imported notation notation2 is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Notation"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemNS" type="DOMString"/> |
| <var name="docElemName" type="DOMString"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="notationImported" type="Notation"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="docElemNS" obj="docElem" interface="Node"/> |
| <localName var="docElemName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='docElemNS' qualifiedName='docElemName' doctype="nullDocType"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notationsMap" obj="docType"/> |
| <getNamedItem var="notation" obj="notationsMap" name='"notation2"'/> |
| <importNode var="notationImported" obj="newDoc" importedNode="notation" deep="true"/> |
| <baseURI var="baseURI" obj="notationImported" interface="Node"/> |
| <assertNull actual="baseURI" id="nodegetbaseuri14"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri15.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri15"> |
| <metadata> |
| <title>nodegetbaseuri15</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Node.getBaseURI for an Attr is null. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2004-01-07</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Attr"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="attrNode" type="Attr"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="bodyElem" type="Element"/> |
| <load var="doc" href="barfoo_base" willBeModified="true"/> |
| <getElementsByTagName var="bodyList" obj="doc" |
| tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attrNode" obj="bodyElem" name='"id"'/> |
| <baseURI var="baseURI" obj="attrNode" interface="Node"/> |
| <assertNull actual="baseURI" id="baseURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri16.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri16"> |
| <metadata> |
| <title>nodegetbaseuri16</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Node.getBaseURI for an EntityReference to should be the baseURI where the entity declaration occurs. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2004-01-07</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2EntityReference"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <load var="doc" href="external_barfoo" willBeModified="false"/> |
| <getElementsByTagName var="pList" obj="doc" |
| tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- the last child should be a entity reference to ent1 ref --> |
| <lastChild var="entRef" obj="pElem" interface="Node"/> |
| <baseURI var="baseURI" obj="entRef" interface="Node"/> |
| <assertURIEquals actual="baseURI" isAbsolute="true" name='"external_barfoo"' id="baseURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri17.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri17"> |
| <metadata> |
| <title>nodegetbaseuri17</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Node.getBaseURI for an text node is null. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2004-01-07</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Text"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="textNode" type="Text"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <load var="doc" href="barfoo_base" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" |
| tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="textNode" obj="pElem" interface="Node"/> |
| <baseURI var="baseURI" obj="textNode" interface="Node"/> |
| <assertNull actual="baseURI" id="baseURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri18.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri18"> |
| <metadata> |
| <title>nodegetbaseuri18</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Node.getBaseURI for an comment node is null. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2004-01-07</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2Comment"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="comment" type="Comment"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <load var="doc" href="barfoo_base" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" |
| tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <nextSibling var="comment" obj="pElem" interface="Node"/> |
| <baseURI var="baseURI" obj="comment" interface="Node"/> |
| <assertNull actual="baseURI" id="baseURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri19.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri19"> |
| <metadata> |
| <title>nodegetbaseuri19</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks baseURI for a text node is null. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2004-01-07</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2DocumentType"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2EntityReference"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="entBaseURI" type="DOMString"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <load var="doc" href="external_barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" |
| tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <assertNotNull actual="pElem" id="pElemNotNull"/> |
| <if> |
| <implementationAttribute name="expandEntityReferences" value="true"/> |
| <firstChild var="textNode" obj="pElem" interface="Node"/> |
| <assertNotNull actual="textNode" id="expansionNotNull"/> |
| <else> |
| <lastChild var="entRef" obj="pElem" interface="Node"/> |
| <assertNotNull actual="entRef" id="entRefNotNull"/> |
| <firstChild var="textNode" obj="entRef" interface="Node"/> |
| <assertNotNull actual="textNode" id="entRefTextNotNull"/> |
| </else> |
| </if> |
| <baseURI var="baseURI" obj="textNode" interface="Node"/> |
| <assertNull actual="baseURI" id="baseURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetbaseuri20.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetbaseuri20"> |
| <metadata> |
| <title>nodegetbaseuri20</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| baseURI for an element from an entity reference should be the URI of the |
| external entity if there is now xml:base attribute. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2004-01-07</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-baseURI"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=419"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/infoset-mapping#Infoset2EntityReference"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="baseURI" type="DOMString"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <load var="doc" href="external_barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" |
| tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="2" interface="NodeList"/> |
| <assertNotNull actual="pElem" id="pElemNotNull"/> |
| <baseURI var="baseURI" obj="pElem" interface="Node"/> |
| <assertURIEquals actual="baseURI" isAbsolute="true" name='"external_widget"' id="equalsExternalBarFoo"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature01.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature01"> |
| <metadata> |
| <title>nodegetfeature01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on Document. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <assign var="node" value="doc"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="doc" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="doc" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="doc" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="doc" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="doc" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="doc" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="doc" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="doc" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="doc" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature02.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature02"> |
| <metadata> |
| <title>nodegetfeature02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on DocumentFragment. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentFragment var="node" obj="doc"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature03.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature03"> |
| <metadata> |
| <title>nodegetfeature03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on DocumentType. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <doctype var="node" obj="doc"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature04.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature04"> |
| <metadata> |
| <title>nodegetfeature04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on EntityReference. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createEntityReference var="node" obj="doc" name='"ent1"'/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature05.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature05"> |
| <metadata> |
| <title>nodegetfeature05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on Element. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <documentElement var="node" obj="doc"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature06.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature06"> |
| <metadata> |
| <title>nodegetfeature06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on non-namespace attribute. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createAttribute var="node" obj="doc" name='"title"'/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature07.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature07"> |
| <metadata> |
| <title>nodegetfeature07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on namespaced attribute. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createAttributeNS var="node" obj="doc" |
| namespaceURI='"http://www.w3.org/XML/1998/namespace"' |
| qualifiedName='"xml:lang"'/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature08.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature08"> |
| <metadata> |
| <title>nodegetfeature08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on ProcessingInstruction. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <hasFeature feature='"XML"'/> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createProcessingInstruction var="node" obj="doc" target='"test-pi"' data='"foo"'/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature09.xml |
|---|
| 0,0 → 1,80 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature09"> |
| <metadata> |
| <title>nodegetfeature09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on Comment. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createComment var="node" obj="doc" data='"test comment"'/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature10.xml |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature10"> |
| <metadata> |
| <title>nodegetfeature10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on Text. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nodeList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <getElementsByTagName var="nodeList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="nodeList" index="0" interface="NodeList"/> |
| <firstChild var="node" obj="elem" interface="Node"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature11.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature11"> |
| <metadata> |
| <title>nodegetfeature11</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on CDATASection. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createCDATASection var="node" obj="doc" data='"some text"'/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature12.xml |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature12"> |
| <metadata> |
| <title>nodegetfeature12</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on Entity. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="doctype" type="DocumentType"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <doctype var="doctype" obj="doc"/> |
| <entities var="entities" obj="doctype"/> |
| <getNamedItem var="node" obj="entities" name='"ent1"'/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetfeature13.xml |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetfeature13"> |
| <metadata> |
| <title>nodegetfeature13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check implementation of Node.getFeature on Notation. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getFeature"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <var name="featureImpl" type="Node"/> |
| <var name="isSupported" type="boolean"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="doctype" type="DocumentType"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <doctype var="doctype" obj="doc"/> |
| <notations var="notations" obj="doctype"/> |
| <getNamedItem var="node" obj="notations" name='"notation1"'/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Core"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="coreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="cOrEUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"+cOrE"' version="nullVersion"/> |
| <assertSame actual="featureImpl" expected="node" id="PlusCoreUnspecifiedVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"org.w3c.domts.bogus.feature"' version="nullVersion"/> |
| <assertNull actual="featureImpl" id="unrecognizedFeature"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"2.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core20"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"cOrE"' version='"3.0"'/> |
| <assertSame actual="featureImpl" expected="node" id="Core30"/> |
| <!-- ask for some well-known feature, |
| can't say that they will be supported but they should not throw an exception --> |
| <isSupported var="isSupported" obj="node" feature='"XML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="SVGUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="HTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"Events"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"Events"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="EventsUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"LS-Async"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"LS-Async"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="LSAsyncUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"XPath"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"XPath"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertSame actual="featureImpl" expected="node" id="XPathUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+HTML"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"HTML"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusHTMLUnspecified"/></if> |
| <isSupported var="isSupported" obj="node" feature='"+SVG"' version="nullVersion"/> |
| <getFeature interface="Node" var="featureImpl" obj="node" feature='"SVG"' version='nullVersion'/> |
| <if><isTrue value="isSupported"/><assertNotNull actual="featureImpl" id="PlusSVGUnspecified"/></if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent01.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent01"> |
| <metadata> |
| <title>nodegettextcontent01</title> |
| <creator>IBM</creator> |
| <description> |
| Using getTextContent on this Document node check if the value returned is Null . |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <textContent var="textContent" obj="doc"/> |
| <assertNull actual="textContent" id="nodegettextcontent01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent02.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent02"> |
| <metadata> |
| <title>nodegettextcontent02</title> |
| <creator>IBM</creator> |
| <description> |
| Using getTextContent on a new Document node check if the value returned is Null . |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="rootNS" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <textContent var="textContent" obj="newDoc"/> |
| <assertNull actual="textContent" id="nodegettextcontent02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent03.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent03"> |
| <metadata> |
| <title>nodegettextcontent03</title> |
| <creator>IBM</creator> |
| <description> |
| Using getTextContent on this DocumentType node check if the value returned is Null . |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="newDoc" type="Document"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <textContent var="textContent" obj="docType"/> |
| <assertNull actual="textContent" id="nodegettextcontent03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent04.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent04"> |
| <metadata> |
| <title>nodegettextcontent04</title> |
| <creator>IBM</creator> |
| <description> |
| Using getTextContent on a new DocumentType node check if the value returned is Null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="nullPubId" type="DOMString" isNull="true"/> |
| <var name="nullSysId" type="DOMString" isNull="true"/> |
| <var name="oldDocType" type="DocumentType"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="oldDocType" obj="doc"/> |
| <name var="rootName" obj="oldDocType" interface="DocumentType"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="docType" obj="domImpl" qualifiedName="rootName" publicId="nullPubId" systemId="nullSysId"/> |
| <textContent var="textContent" obj="docType"/> |
| <assertNull actual="textContent" id="nodegettextcontent04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent05.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent05"> |
| <metadata> |
| <title>nodegettextcontent05</title> |
| <creator>IBM</creator> |
| <description> |
| Using getTextContent on this DocumentType node check if the value returned is Null . |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="notation1" type="Notation"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notationsMap" obj="docType"/> |
| <getNamedItem var="notation1" obj="notationsMap" name='"notation1"'/> |
| <textContent var="textContent" obj="docType"/> |
| <assertNull actual="textContent" id="nodegettextcontent05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent06.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent06"> |
| <metadata> |
| <title>nodegettextcontent06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on a default Attr node and check if the value returned |
| is the attributes Value. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="elem" name='"dir"'/> |
| <textContent var="textContent" obj="attr"/> |
| <assertEquals actual="textContent" expected='"rtl"' id="nodegettextcontent06" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent07.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent07"> |
| <metadata> |
| <title>nodegettextcontent07</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on a new Attr node and check if the value returned |
| is the attributes Value. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <setAttributeNS obj="elem" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"' value='"en-US"'/> |
| <getAttributeNodeNS var="attr" obj="elem" namespaceURI='"http://www.w3.org/XML/1998/namespace"' localName='"lang"'/> |
| <textContent var="textContent" obj="attr"/> |
| <assertEquals actual="textContent" expected='"en-US"' id="nodegettextcontent07" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent08.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent08"> |
| <metadata> |
| <title>nodegettextcontent08</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on a new Attr node and check if the value returned |
| is the attributes Value. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="att" type="Attr"/> |
| <var name="attr" type="Attr"/> |
| <var name="replacedAttr" type="Attr"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"'/> |
| <createAttributeNS var="att" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <setAttributeNodeNS obj="elem" var="replacedAttr" newAttr="att"/> |
| <getAttributeNodeNS var="attr" obj="elem" namespaceURI='"http://www.w3.org/XML/1998/namespace"' localName='"lang"'/> |
| <textContent var="textContent" obj="attr"/> |
| <assertEquals actual="textContent" expected='""' id="nodegettextcontent08" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent09.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent09"> |
| <metadata> |
| <title>nodegettextcontent09</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on a new Text node and check if the value returned |
| is the text content. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"'/> |
| <createTextNode var="txt" obj="doc" data='"Replacement Text"' /> |
| <appendChild obj="elem" var="appendedChild" newChild="txt"/> |
| <textContent var="textContent" obj="txt"/> |
| <assertEquals actual="textContent" expected='"Replacement Text"' id="nodegettextcontent09" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent10.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent10"> |
| <metadata> |
| <title>nodegettextcontent10</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on an existing Text node and check if the value returned |
| is the elements Text content. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <firstChild var="txt" obj="elem" interface="Node"/> |
| <textContent var="textContent" obj="txt"/> |
| <assertEquals actual="textContent" expected='"EMP0001"' id="nodegettextcontent10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent11.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent11"> |
| <metadata> |
| <title>nodegettextcontent11</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on an existing CDATASection node and check if the value returned |
| is the CDATASections content. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="1" interface="NodeList"/> |
| <lastChild var="cdata" obj="elem" interface="Node"/> |
| <textContent var="textContent" obj="cdata"/> |
| <assertEquals actual="textContent" expected='"This is an adjacent CDATASection with a reference to a tab &tab;"' id="nodegettextcontent11" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent12.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent12"> |
| <metadata> |
| <title>nodegettextcontent12</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on a new Comment node and check if the value returned |
| is the Comments data. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="comment" type="Comment"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"body"'/> |
| <createComment var="comment" obj="doc" data='"Comment"' /> |
| <appendChild obj="elem" var="appendedChild" newChild="comment"/> |
| <textContent var="textContent" obj="comment"/> |
| <assertEquals actual="textContent" expected='"Comment"' id="nodegettextcontent12" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent13.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent13"> |
| <metadata> |
| <title>nodegettextcontent13</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on an existing Element node with Text and CDATA |
| content and check if the value returned is a single concatenated String with its content. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="1" interface="NodeList"/> |
| <textContent var="textContent" obj="elem"/> |
| <assertEquals actual="textContent" expected='"Martha Raynolds\nThis is a CDATASection with EntityReference number 2 &ent2;\nThis is an adjacent CDATASection with a reference to a tab &tab;"' id="nodegettextcontent13" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent14.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent14"> |
| <metadata> |
| <title>nodegettextcontent14</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on an existing Element node with Child Element, Text |
| EntityReferences and Attributes and check if the value returned is a single |
| concatenated String with its content. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="2" interface="NodeList"/> |
| <textContent var="textContent" obj="elem"/> |
| <assertEquals actual="textContent" expected='"\n EMP0003\n Roger\n Jones\n Department Manager\n 100,000\n Element data\n PO Box 27 Irving, texas 98553\n "' id="nodegettextcontent13" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent15.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent15"> |
| <metadata> |
| <title>nodegettextcontent15</title> |
| <creator>IBM</creator> |
| <description> |
| The method getTextContent returns the text content of this node and its descendants. |
| Invoke the method getTextContent on a new Element node with new Text, EntityReferences |
| CDATASection, PI and Comment nodes and check if the value returned is a single |
| concatenated String with its content. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="comment" type="Comment"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom3:elem"'/> |
| <createTextNode var="txt" obj="doc" data='"Text "' /> |
| <createComment var="comment" obj="doc" data='"Comment "' /> |
| <createEntityReference var="entRef" obj="doc" name='"beta"' /> |
| <createProcessingInstruction var="pi" obj="doc" target='"PIT"' data='"PIData "'/> |
| <createCDATASection var="cdata" obj="doc" data='"CData"' /> |
| <appendChild obj="elem" var="appendedChild" newChild="txt"/> |
| <appendChild obj="elem" var="appendedChild" newChild="comment"/> |
| <appendChild obj="elem" var="appendedChild" newChild="entRef"/> |
| <appendChild obj="elem" var="appendedChild" newChild="pi"/> |
| <appendChild obj="elem" var="appendedChild" newChild="cdata"/> |
| <textContent var="textContent" obj="elem"/> |
| <normalizeDocument obj="doc" /> |
| <assertEquals actual="textContent" expected='"Text βCData"' id="nodegettextcontent15" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent16.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent16"> |
| <metadata> |
| <title>nodegettextcontent16</title> |
| <creator>IBM</creator> |
| <description> |
| The method getTextContent returns the text content of this node and its descendants. |
| Invoke the method getTextContent on a new DocumentFragment node with new Text, EntityReferences |
| CDATASection, PI and Comment nodes and check if the value returned is a single |
| concatenated String with its content. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="elem" type="Element"/> |
| <var name="elemChild" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="comment" type="Comment"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom3:elem"'/> |
| <createTextNode var="txt" obj="doc" data='"Text "' /> |
| <createComment var="comment" obj="doc" data='"Comment "' /> |
| <createEntityReference var="entRef" obj="doc" name='"beta"' /> |
| <createProcessingInstruction var="pi" obj="doc" target='"PIT"' data='"PIData "'/> |
| <createCDATASection var="cdata" obj="doc" data='"CData"' /> |
| <appendChild obj="elem" var="appendedChild" newChild="txt"/> |
| <appendChild obj="elem" var="appendedChild" newChild="comment"/> |
| <appendChild obj="elem" var="appendedChild" newChild="entRef"/> |
| <appendChild obj="elem" var="appendedChild" newChild="pi"/> |
| <appendChild obj="elem" var="appendedChild" newChild="cdata"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="elem"/> |
| <normalizeDocument obj="doc" /> |
| <textContent var="textContent" obj="docFrag"/> |
| <assertEquals actual="textContent" expected='"Text βCData"' id="nodegettextcontent16" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent17.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent17"> |
| <metadata> |
| <title>nodegettextcontent17</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on a new EntityReference node and check if the |
| value returned is the EntityReference's content. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="elem" obj="doc"/> |
| <createEntityReference var="entRef" obj="doc" name='"beta"' /> |
| <appendChild obj="elem" var="appendedChild" newChild="entRef"/> |
| <textContent var="textContent" obj="entRef"/> |
| <assertEquals actual="textContent" expected='"β"' id="nodegettextcontent17" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent18.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent18"> |
| <metadata> |
| <title>nodegettextcontent18</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke the method getTextContent on an Entity node and check if the value returned |
| is its replacement text. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entity" type="Entity"/> |
| <var name="entitymap" type="NamedNodeMap"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitymap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitymap" name='"delta"'/> |
| <textContent var="textContent" obj="entity"/> |
| <assertEquals actual="textContent" expected='"δ"' id="nodegettextcontent18" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegettextcontent19.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegettextcontent19"> |
| <metadata> |
| <title>nodegettextcontent19</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that element content whitespace is not added to textContent. Determination |
| of element content whitespace is only assured if validating. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=538"/> |
| </metadata> |
| <implementationAttribute name="ignoringElementContentWhitespace" value="false"/> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <textContent var="textContent" obj="elem"/> |
| <assertEquals actual="textContent" expected='"bar"' id="textContent" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetuserdata01.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetuserdata01"> |
| <metadata> |
| <title>nodegetuserdata01</title> |
| <creator>IBM</creator> |
| <description> |
| Using getUserData with a junk value for the key attempt to retreive the UserData object |
| of this Document node without setting it and verify if null is returned. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="userData" type="DOMUserData"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getUserData var="userData" obj="doc" key='"key1"'/> |
| <assertNull actual="userData" id="nodegetuserdata01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetuserdata02.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetuserdata02"> |
| <metadata> |
| <title>nodegetuserdata02</title> |
| <creator>IBM</creator> |
| <description> |
| Using getUserData with a junk value for the key attempt to retreive the UserData object |
| of this Document node without setting it and verify if null is returned. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="userData" type="DOMUserData"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getUserData var="userData" obj="doc" key='"key1"'/> |
| <assertNull actual="userData" id="nodegetuserdata02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetuserdata03.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetuserdata03"> |
| <metadata> |
| <title>nodegetuserdata03</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on this Document to set this Documents UserData to a new |
| Element node and using getUserData and isEqualNode check if the returned |
| UserData object is the same as the object that was set. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="success" type="boolean"/> |
| <var name="elem" type="Element"/> |
| <var name="returnedUserData" type="DOMUserData"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"body"' /> |
| <setUserData obj="doc" var="returnedUserData" key='"something"' data="elem" handler="nullHandler"/> |
| <getUserData var="retUserData" obj="doc" key='"something"'/> |
| <isEqualNode var="success" obj="retUserData" arg="elem"/> |
| <assertTrue actual="success" id="nodegetuserdata03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetuserdata04.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetuserdata04"> |
| <metadata> |
| <title>nodegetuserdata04</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on this DocumentType to set this its UserData to a this |
| Document node and using getUserData and isEqualNode check if the returned |
| UserData object is the same as the object that was set. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="success" type="boolean"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <var name="prevUserData" type="DOMUserData"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <setUserData obj="docType" var="prevUserData" key='"KeyDoc"' data="doc" handler="nullHandler"/> |
| <getUserData var="retUserData" obj="docType" key='"KeyDoc"'/> |
| <isEqualNode var="success" obj="retUserData" arg="doc"/> |
| <assertTrue actual="success" id="nodegetuserdata04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetuserdata05.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetuserdata05"> |
| <metadata> |
| <title>nodegetuserdata05</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on this Entity node to set this its UserData to a new |
| Attr node and using getUserData with an invalid Key check if the returned |
| UserData object is Null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="attr" type="Attr"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <var name="prevUserData" type="DOMUserData"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entities" obj="docType"/> |
| <getNamedItem var="entity" obj="entities" name='"delta"'/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"lang"'/> |
| <setUserData obj="entity" var="prevUserData" key='"key"' data="attr" handler="nullHandler"/> |
| <getUserData var="retUserData" obj="entity" key='"Key"'/> |
| <assertNull actual="retUserData" id="nodegetuserdata05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetuserdata06.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetuserdata06"> |
| <metadata> |
| <title>nodegetuserdata06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke getUserData on a new Text node with an ampty Key check if the returned |
| UserData object is Null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="txt" type="Text"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createTextNode var="txt" obj="doc" data='"TEXT"'/> |
| <getUserData var="retUserData" obj="txt" key='""'/> |
| <assertNull actual="retUserData" id="nodegetuserdata06"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodegetuserdata07.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodegetuserdata07"> |
| <metadata> |
| <title>nodegetuserdata07</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on a new PI node to set this its UserData to itself |
| and using getUserData with an valid Key and isEqualsNode check if the |
| returned UserData object is the same as that was set. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-getUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="success" type="boolean"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <var name="prevUserData" type="DOMUserData"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createProcessingInstruction var="pi" obj="doc" data='"PIDATA"' target='"PITARGET"'/> |
| <setUserData obj="pi" var="prevUserData" key='"key"' data="pi" handler="nullHandler"/> |
| <getUserData var="retUserData" obj="pi" key='"key"'/> |
| <isEqualNode var="success" obj="retUserData" arg="pi"/> |
| <assertTrue actual="success" id="nodegetuserdata07"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore01.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore01"> |
| <metadata> |
| <title>nodeinsertbefore01</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on this Document node attempt to insert a new Comment node before |
| this DocumentElement node and verify the name of the inserted Comment node. Now |
| attempt to insert a new Processing Instruction node before the new Comment and |
| verify the target of the inserted ProcessingInstruction. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="newComment" type="Comment"/> |
| <var name="insertedComment" type="Comment"/> |
| <var name="data" type="DOMString"/> |
| <var name="newPI" type="ProcessingInstruction"/> |
| <var name="insertedPI" type="ProcessingInstruction"/> |
| <var name="target" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createComment var="newComment" obj="doc" data='"Comment"' /> |
| <createProcessingInstruction var="newPI" obj="doc" target='"PITarget"' data='"PIData"' /> |
| <insertBefore var="insertedComment" obj="doc" newChild="newComment" refChild="docElem"/> |
| <data var="data" obj="insertedComment" interface="CharacterData"/> |
| <assertEquals actual="data" expected='"Comment"' id="nodeinsertbefore01_1" ignoreCase="false"/> |
| <insertBefore var="insertedPI" obj="doc" newChild="newPI" refChild="newComment"/> |
| <target var="target" obj="insertedPI" interface="ProcessingInstruction"/> |
| <assertEquals actual="target" expected='"PITarget"' id="nodeinsertbefore01_2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore02.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore02"> |
| <metadata> |
| <title>nodeinsertbefore02</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on a new Document node attempt to insert a new Comment node before |
| this DocumentType node and verify the name of the inserted Comment node. Now |
| attempt to insert a new Processing Instruction node before the new Comment and |
| verify the target of the inserted ProcessingInstruction. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDocType" type="DocumentType"/> |
| <var name="newComment" type="Comment"/> |
| <var name="insertedComment" type="Comment"/> |
| <var name="data" type="DOMString"/> |
| <var name="newPI" type="ProcessingInstruction"/> |
| <var name="insertedPI" type="ProcessingInstruction"/> |
| <var name="target" type="DOMString"/> |
| <var name="nullPubId" type="DOMString" isNull="true"/> |
| <var name="nullSysId" type="DOMString" isNull="true"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="docElem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="newDocType" obj="domImpl" qualifiedName="rootName" publicId="nullPubId" systemId="nullSysId"/> |
| <createDocument var="newDoc" obj="domImpl" qualifiedName="rootName" namespaceURI="rootNS" doctype="newDocType" /> |
| <createComment var="newComment" obj="newDoc" data='"Comment"' /> |
| <createProcessingInstruction var="newPI" obj="newDoc" target='"PITarget"' data='"PIData"' /> |
| <insertBefore var="insertedComment" obj="newDoc" newChild="newComment" refChild="newDocType"/> |
| <data var="data" obj="insertedComment" interface="CharacterData"/> |
| <assertEquals actual="data" expected='"Comment"' id="nodeinsertbefore02_1" ignoreCase="false"/> |
| <insertBefore var="insertedPI" obj="newDoc" newChild="newPI" refChild="newComment"/> |
| <target var="target" obj="insertedPI" interface="ProcessingInstruction"/> |
| <assertEquals actual="target" expected='"PITarget"' id="nodeinsertbefore02_2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore03.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore03"> |
| <metadata> |
| <title>nodeinsertbefore03</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on this Document node attempt to insert a new Attr node before |
| this DocumentType node and verify if a HIERARCHY_REQUEST_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <createAttributeNS var="newAttr" obj="doc" qualifiedName='"xml:lang"' namespaceURI='"http://www.w3.org/XML/1998/namespace"'/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore obj="doc" var="inserted" newChild="newAttr" refChild="docType"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore04.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore04"> |
| <metadata> |
| <title>nodeinsertbefore04</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on this Document node attempt to insert this Document node before |
| this DocumentType node and verify if a HIERARCHY_REQUEST_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore obj="doc" var="inserted" newChild="doc" refChild="docType"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore05.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore05"> |
| <metadata> |
| <title>nodeinsertbefore05</title> |
| <creator>IBM</creator> |
| <description> |
| Attempt to insert a second DocumentType node in a document using Node.insertBefore, |
| should raise either DOMException with either a HIERARCHY_REQUEST_ERR |
| or NOT_SUPPORTED_ERR code. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDocType" type="DocumentType"/> |
| <var name="inserted" type="Node"/> |
| <var name="nullPubId" type="DOMString" isNull="true"/> |
| <var name="nullSysId" type="DOMString" isNull="true"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <name var="rootName" obj="docType" interface="DocumentType"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="newDocType" obj="domImpl" qualifiedName="rootName" publicId="nullPubId" systemId="nullSysId"/> |
| <try> |
| <insertBefore obj="doc" var="inserted" newChild="newDocType" refChild="docType"/> |
| <fail id="throw_DOMException"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NOT_SUPPORTED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore06.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore06"> |
| <metadata> |
| <title>nodeinsertbefore06</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on this Document node attempt to insert an Element node before |
| the existing element node and verify if a HIERARCHY_REQUEST_ERR or NOT_SUPPORTED_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=415"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="inserted" type="Node"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootTagname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootTagname" obj="docElem"/> |
| <createElementNS var="newElem" obj="doc" qualifiedName='rootTagname' namespaceURI='rootNS'/> |
| <try> |
| <insertBefore obj="doc" var="inserted" newChild="newElem" refChild="docElem"/> |
| <fail id="throw_DOMException"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NOT_SUPPORTED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore07.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore07"> |
| <metadata> |
| <title>nodeinsertbefore07</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on this Document node attempt to insert a Comment node created by |
| another Document before this DocumentElement node and verify if a WRONG_DOCUMENT_ERR |
| is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docAlt" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="newComment" type="Comment"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <load var="docAlt" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createComment var="newComment" obj="docAlt" data='"Comment"' /> |
| <assertDOMException id="WRONG_DOCUMENT_ERR_nodeinsertbefore07"> |
| <WRONG_DOCUMENT_ERR> |
| <insertBefore obj="doc" var="inserted" newChild="newComment" refChild="docElem"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore08.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore08"> |
| <metadata> |
| <title>nodeinsertbefore08</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on this Document node attempt to insert a Comment node created by |
| this Document before another Document's DocumentElement node and verify if a |
| NOT_FOUND_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docAlt" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="newComment" type="Comment"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <load var="docAlt" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="docAlt"/> |
| <createComment var="newComment" obj="doc" data='"Comment"' /> |
| <assertDOMException id="NOT_FOUND_ERR_nodeinsertbefore08"> |
| <NOT_FOUND_ERR> |
| <insertBefore obj="doc" var="inserted" newChild="newComment" refChild="docElem"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore09.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore09"> |
| <metadata> |
| <title>nodeinsertbefore09</title> |
| <creator>IBM</creator> |
| <description> |
| The method insertBefore inserts the node newChild before the existing child node refChild. |
| If refChild is null, insert newChild at the end of the list of children. |
| If newChild is a DocumentFragment object, all of its children are inserted, in the same |
| order, before refChild. |
| Using insertBefore on this Document node attempt to insert a new DocumentFragment node |
| before a Comment node and verify the contents of the Comment node that is a child |
| of the DocumentFragment. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="newComment" type="Comment"/> |
| <var name="insertComment" type="Comment"/> |
| <var name="comment" type="Comment"/> |
| <var name="inserted" type="DocumentFragment"/> |
| <var name="data" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createComment var="newComment" obj="doc" data='"Comment"' /> |
| <appendChild obj="doc" var="appendedChild" newChild="newComment"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createComment var="insertComment" obj="doc" data='"insertComment"' /> |
| <appendChild obj="docFrag" var="appendedChild" newChild="insertComment"/> |
| <insertBefore var="inserted" obj="doc" newChild="docFrag" refChild="newComment"/> |
| <previousSibling var="comment" obj="newComment" interface="Node"/> |
| <data var="data" obj="comment" interface="CharacterData"/> |
| <assertEquals actual="data" expected='"insertComment"' id="nodeinsertbefore09" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore10.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore10"> |
| <metadata> |
| <title>nodeinsertbefore10</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on this Document node attempt to insert a new Element node before |
| another Element node and verify a DOMException with a |
| HIERARCHY_REQUEST_ERR, NOT_FOUND_ERR or NOT_SUPPORTED_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=415"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="inserted" type="Node"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootTagname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootTagname" obj="docElem"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="1" interface="NodeList"/> |
| <createElementNS var="newElem" obj="doc" qualifiedName='rootTagname' namespaceURI='rootNS'/> |
| <try> |
| <insertBefore obj="doc" var="inserted" newChild="newElem" refChild="elem"/> |
| <fail id="throw_DOMException"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NOT_FOUND_ERR"/> |
| <DOMException code="NOT_SUPPORTED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore11.xml |
|---|
| 0,0 → 1,77 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore11"> |
| <metadata> |
| <title>nodeinsertbefore11</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on a DocumentFragment node attempt to insert a child nodes before |
| other permissible nodes and verify the contents/name of each inserted node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="elem" type="Element"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="comment" type="Comment"/> |
| <var name="txt" type="Text"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="eRef" type="EntityReference"/> |
| <var name="inserted" type="Node"/> |
| <var name="insertedVal" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createElementNS var="elem" obj="doc" qualifiedName='"body"' namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <createProcessingInstruction var="pi" obj="doc" target='"PITarget"' data='"PIData"' /> |
| <createComment var="comment" obj="doc" data='"Comment"' /> |
| <createTextNode var="txt" obj="doc" data='"Text"' /> |
| <createCDATASection var="cdata" obj="doc" data='"CDATA"' /> |
| <createEntityReference var="eRef" obj="doc" name='"alpha"' /> |
| <appendChild obj="docFrag" var="appendedChild" newChild="elem"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="pi"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="comment"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="txt"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="cdata"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="eRef"/> |
| <!-- |
| <insertBefore var="inserted" obj="docFrag" newChild="pi" refChild="elem" /> |
| <target var="insertedVal" obj="inserted" interface="ProcessingInstruction"/> |
| <assertEquals actual="insertedVal" expected='"PITarget"' id="nodeinsertbefore11"/> |
| --> |
| <insertBefore var="inserted" obj="docFrag" newChild="comment" refChild="pi"/> |
| <data var="insertedVal" obj="inserted" interface="CharacterData"/> |
| <assertEquals actual="insertedVal" expected='"Comment"' id="nodeinsertbefore11_Comment" ignoreCase="false"/> |
| <insertBefore var="inserted" obj="docFrag" newChild="txt" refChild="comment"/> |
| <data var="insertedVal" obj="inserted" interface="CharacterData"/> |
| <assertEquals actual="insertedVal" expected='"Text"' id="nodeinsertbefore11_Text" ignoreCase="false"/> |
| <insertBefore var="inserted" obj="docFrag" newChild="cdata" refChild="txt"/> |
| <data var="insertedVal" obj="inserted" interface="CharacterData"/> |
| <assertEquals actual="insertedVal" expected='"CDATA"' id="nodeinsertbefore11_CDATA" ignoreCase="false"/> |
| <insertBefore var="inserted" obj="docFrag" newChild="eRef" refChild="cdata"/> |
| <nodeName var="insertedVal" obj="inserted" /> |
| <assertEquals actual="insertedVal" expected='"alpha"' id="nodeinsertbefore11_Ent1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore12.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore12"> |
| <metadata> |
| <title>nodeinsertbefore12</title> |
| <creator>IBM</creator> |
| <description> |
| The method insertBefore inserts the node newChild before the existing child node refChild. |
| If refChild is null, insert newChild at the end of the list of children. |
| Using insertBefore on a DocumentFragment node attempt to insert a new DocumentFragment node |
| before this DocumentFragment's Element node and verify the last child is still the only child |
| appended to docFrag. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="docFragNew" type="DocumentFragment"/> |
| <var name="elem" type="Element"/> |
| <var name="inserted" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="last" type="Node"/> |
| <var name="name" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createDocumentFragment var="docFragNew" obj="doc"/> |
| <createElementNS var="elem" obj="doc" qualifiedName='"dom3:elem"' namespaceURI='"http://www.w3.org/DOM/Test"'/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="elem"/> |
| <insertBefore obj="docFrag" var="inserted" newChild="docFragNew" refChild="elem"/> |
| <lastChild obj="docFrag" var="last" interface="Node"/> |
| <nodeName obj="last" var="name" interface="Node"/> |
| <assertEquals actual="name" expected='"dom3:elem"' id="nodeinsertbefore12" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore13.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore13"> |
| <metadata> |
| <title>nodeinsertbefore13</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on a DocumentFragment node attempt to insert a new Element node |
| created by another Document, before this DocumentFragment's Element node and |
| verify if a WRONG_DOCUMENT_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docAlt" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="elemAlt" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="inserted" type="Node"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootTagname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootTagname" obj="docElem"/> |
| <load var="docAlt" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createElementNS var="elem" obj="doc" qualifiedName='rootTagname' namespaceURI='rootNS'/> |
| <createElementNS var="elemAlt" obj="docAlt" qualifiedName='rootTagname' namespaceURI='rootNS'/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="elem"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <insertBefore obj="docFrag" var="inserted" newChild="elemAlt" refChild="elem"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore14.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore14"> |
| <metadata> |
| <title>nodeinsertbefore14</title> |
| <creator>IBM</creator> |
| <description> |
| The method insertBefore inserts the node newChild before the existing child node refChild. |
| If refChild is null, insert newChild at the end of the list of children. |
| A NO_MODIFICATION_ALLOWED_ERR is raised if the node is read-only. |
| Using insertBefore on this Document node attempt to insert a new Attr node before |
| this DocumentType node and verfiy if a NO_MODIFICATION_ALLOWED_ERR is raised. |
| (This can also raise a HIERARCHY_REQUEST_ERR and NOT_FOUND_ERR) |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="newAttr" type="Attr"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <createAttributeNS var="newAttr" obj="doc" qualifiedName='"dom3:attr"' namespaceURI='"http://www.w3.org/DOM/Test"'/> |
| <assertDOMException id="NO_MODIFICATION_ALLOWED_ERR_nodeinsertbefore14"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertBefore obj="docType" var="inserted" newChild="newAttr" refChild="docType"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore15.xml |
|---|
| 0,0 → 1,76 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore15"> |
| <metadata> |
| <title>nodeinsertbefore15</title> |
| <creator>IBM</creator> |
| <description> |
| A NO_MODIFICATION_ALLOWED_ERR is raised if the node is read-only. |
| Using insertBefore on a new EntityReference node attempt to insert Element, Text, |
| Comment, ProcessingInstruction and CDATASection nodes before an element child |
| and verify if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="elemChild" type="Node"/> |
| <var name="txt" type="Text"/> |
| <var name="elem" type="Element"/> |
| <var name="comment" type="Comment"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEntityReference var="entRef" obj="doc" name='"delta"'/> |
| <firstChild obj="entRef" var="elemChild" interface="Node"/> |
| <createCDATASection var="cdata" obj="doc" data='"CDATASection"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_1"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertBefore obj="entRef" var="inserted" refChild="elemChild" newChild="cdata"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <createProcessingInstruction var="pi" obj="doc" target='"target"' data='"data"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_2"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertBefore obj="entRef" var="inserted" refChild="elemChild" newChild="pi"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <createComment var="comment" obj="doc" data='"Comment"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_3"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertBefore obj="entRef" var="inserted" refChild="elemChild" newChild="comment"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <createTextNode var="txt" obj="doc" data='"Text"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_4"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertBefore obj="entRef" var="inserted" refChild="elemChild" newChild="txt"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"body"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_5"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertBefore obj="entRef" var="inserted" refChild="elemChild" newChild="elem"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore16.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore16"> |
| <metadata> |
| <title>nodeinsertbefore16</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on an Element node attempt to insert a new Element, node before its |
| first element child and verify the name of the new first child node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="refElem" type="Element"/> |
| <var name="firstChild" type="Node"/> |
| <var name="insertedElem" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="element" obj="childList" index="0" interface="NodeList"/> |
| <firstChild var="firstChild" obj="element" interface="Node"/> |
| <nextSibling var="refElem" obj="firstChild" interface="Node"/> |
| <createElementNS var="newElem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:br"'/> |
| <insertBefore obj="element" var="inserted" refChild="refElem" newChild="newElem"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="element" obj="childList" index="0" interface="NodeList"/> |
| <firstChild var="firstChild" obj="element" interface="Node"/> |
| <nextSibling var="insertedElem" obj="firstChild" interface="Node"/> |
| <nodeName var="nodeName" obj="insertedElem"/> |
| <assertEquals actual="nodeName" expected='"xhtml:br"' id="nodeinsertbefore16" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore17.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore17"> |
| <metadata> |
| <title>nodeinsertbefore17</title> |
| <creator>IBM</creator> |
| <description> |
| The method insertBefore inserts the node newChild before the existing child node refChild. |
| If refChild is null, insert newChild at the end of the list of children. |
| Using insertBefore on an Element node attempt to insert a text node before its |
| first element child and verify the name of the new first child node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <implementationAttribute name="coalescing" value="true"/> |
| <implementationAttribute name="ignoringElementContentWhitespace" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="newText" type="Text"/> |
| <var name="refNode" type="Node"/> |
| <var name="firstChild" type="Node"/> |
| <var name="insertedText" type="Text"/> |
| <var name="childList" type="NodeList"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI='"*"' localName='"p"' interface="Document"/> |
| <item var="element" obj="childList" index="1" interface="NodeList"/> |
| <firstChild var="refNode" obj="element" interface="Node"/> |
| <createTextNode var="newText" obj="doc" data='"newText"' interface="Document"/> |
| <insertBefore obj="element" var="inserted" refChild="refNode" newChild="newText"/> |
| <firstChild var="insertedText" obj="element" interface="Node"/> |
| <nodeName var="nodeName" obj="insertedText"/> |
| <assertEquals actual="nodeName" expected='"#text"' id="nodeinsertbefore17" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore18.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore18"> |
| <metadata> |
| <title>nodeinsertbefore18</title> |
| <creator>IBM</creator> |
| <description> |
| The method insertBefore inserts the node newChild before the existing child node refChild. |
| If refChild is null, insert newChild at the end of the list of children. |
| Using insertBefore on an Element node attempt to insert new Comment/PI and CDATA nodes |
| before each other and verify the names of the newly inserted nodes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="newComment" type="Comment"/> |
| <var name="newPI" type="ProcessingInstruction"/> |
| <var name="newCDATA" type="CDATASection"/> |
| <var name="insertedNode" type="Comment"/> |
| <var name="data" type="DOMString"/> |
| <var name="target" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElement var="element" obj="doc" tagName='"element"'/> |
| <createElementNS var="newElem" obj="doc" namespaceURI='"http://www.w3.org/DOM"' qualifiedName='"dom3:elem"'/> |
| <createComment var="newComment" obj="doc" data='"Comment"'/> |
| <createCDATASection var="newCDATA" obj="doc" data='"CDATASection"'/> |
| <createProcessingInstruction var="newPI" obj="doc" target='"target"' data='"data"'/> |
| <appendChild obj="element" var="appendedChild" newChild="newElem"/> |
| <appendChild obj="element" var="appendedChild" newChild="newComment"/> |
| <appendChild obj="element" var="appendedChild" newChild="newPI"/> |
| <appendChild obj="element" var="appendedChild" newChild="newCDATA"/> |
| <insertBefore obj="element" var="inserted" refChild="newElem" newChild="newComment"/> |
| <firstChild var="insertedNode" obj="element" interface="Node"/> |
| <data var="data" obj="insertedNode" interface="CharacterData"/> |
| <assertEquals actual="data" expected='"Comment"' id="nodeinsertbefore18" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore19.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore19"> |
| <metadata> |
| <title>nodeinsertbefore19</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on an Element node attempt to insert an EntityReference node, before |
| another new EntityReference node and verify the name of the new first child node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="refNode" type="Node"/> |
| <var name="newNode" type="EntityReference"/> |
| <var name="inserted" type="EntityReference"/> |
| <var name="childList" type="NodeList"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="element" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"var"' interface="Document"/> |
| <item var="element" obj="childList" index="2" interface="NodeList"/> |
| <firstChild var="refNode" obj="element" interface="Node"/> |
| <createEntityReference var="newNode" obj="doc" name='"alpha"'/> |
| <insertBefore obj="element" var="inserted" refChild="refNode" newChild="newNode"/> |
| <nodeName var="nodeName" obj="inserted"/> |
| <assertEquals actual="nodeName" expected='"alpha"' id="nodeinsertbefore19" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore20.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore20"> |
| <metadata> |
| <title>nodeinsertbefore20</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on an Element node attempt to insert a new Attr node, before |
| an EntityReference child and verify if a HIERARCHY_REQUEST_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="refNode" type="Node"/> |
| <var name="newNode" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"var"' interface="Document"/> |
| <item var="element" obj="childList" index="2" interface="NodeList"/> |
| <firstChild var="refNode" obj="element" interface="Node"/> |
| <createAttributeNS var="newNode" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore obj="element" var="inserted" refChild="refNode" newChild="newNode"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore21.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore21"> |
| <metadata> |
| <title>nodeinsertbefore21</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on an Element node attempt to insert the parent Element node, before |
| an EntityReference or Text child and verify if a HIERARCHY_REQUEST_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="refNode" type="Node"/> |
| <var name="newNode" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"var"' interface="Document"/> |
| <item var="element" obj="childList" index="2" interface="NodeList"/> |
| <firstChild var="refNode" obj="element" interface="Node"/> |
| <parentNode var="newNode" obj="element" interface="Node"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore obj="element" var="inserted" refChild="refNode" newChild="newNode"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore22.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore22"> |
| <metadata> |
| <title>nodeinsertbefore22</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on an Element node attempt to insert the ancestor of an Element node |
| before its child and verify if a HIERARCHY_REQUEST_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="refNode" type="Element"/> |
| <var name="ancestor" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:body"'/> |
| <createElementNS var="refNode" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:a"'/> |
| <createElementNS var="ancestor" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:p"'/> |
| <appendChild obj="element" var="appendedChild" newChild="refNode"/> |
| <appendChild obj="ancestor" var="appendedChild" newChild="element"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <insertBefore obj="element" var="inserted" refChild="refNode" newChild="ancestor"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore23.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore23"> |
| <metadata> |
| <title>nodeinsertbefore23</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on an Element node attempt to insert a Text node created by a different |
| Document before an Element child and verify if a WRONG_DOCUMENT_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="refNode" type="Element"/> |
| <var name="newNode" type="Text"/> |
| <var name="childList" type="NodeList"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <load var="doc2" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:body"'/> |
| <createElementNS var="refNode" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:p"'/> |
| <createTextNode var="newNode" obj="doc2" data='"TextNode"' /> |
| <appendChild obj="element" var="appendedChild" newChild="refNode"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <insertBefore obj="element" var="inserted" refChild="refNode" newChild="newNode"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore24.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore24"> |
| <metadata> |
| <title>nodeinsertbefore24</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on an Element node attempt to insert a Comment node before |
| a CDATASection node that is not a child and verify if a NOT_FOUND_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="refNode" type="CDATASection"/> |
| <var name="newNode" type="Comment"/> |
| <var name="childList" type="NodeList"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="element" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:p"'/> |
| <createCDATASection var="refNode" obj="doc" data='"CDATASection"' /> |
| <createComment var="newNode" obj="doc" data='"Comment"' /> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <insertBefore obj="element" var="inserted" refChild="refNode" newChild="newNode"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeinsertbefore25.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeinsertbefore25"> |
| <metadata> |
| <title>nodeinsertbefore25</title> |
| <creator>IBM</creator> |
| <description> |
| Using insertBefore on a child Element of an EntityReference node attempt to insert |
| a new Element node, before a Text node child of an Entity Node's replacement |
| text and verify if a NO_MODIFICATION_ALLOWED_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-952280727"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="eRef" type="EntityReference"/> |
| <var name="span" type="Element"/> |
| <var name="spanText" type="Text"/> |
| <var name="newNode" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="inserted" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"var"' interface="Document"/> |
| <item var="element" obj="childList" index="2" interface="NodeList"/> |
| <firstChild var="eRef" obj="element" interface="Node"/> |
| <firstChild var="span" obj="eRef" interface="Node"/> |
| <assertNotNull actual="span" id="spanNotNull"/> |
| <firstChild var="spanText" obj="span" interface="Node"/> |
| <assertNotNull actual="spanText" id="spanTextNotNull"/> |
| <createElementNS var="newNode" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"span"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <insertBefore obj="span" var="inserted" refChild="spanText" newChild="newNode"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace01.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace01"> |
| <metadata> |
| <title>nodeisdefaultnamespace01</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on this Document node with the |
| namespace of the document element check if the value returned is true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemNS" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="docElemNS" obj="docElem" interface="Node"/> |
| <isDefaultNamespace var="isDefault" obj="doc" namespaceURI="docElemNS"/> |
| <assertTrue actual="isDefault" id="nodeisdefaultnamespace01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace02.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace02"> |
| <metadata> |
| <title>nodeisdefaultnamespace02</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on on a new Document node with the value of the namespaceURI |
| parameter equal to the namespaceURI of the newly created Document and check if the |
| value returned is false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <localName var="rootName" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <isDefaultNamespace var="isDefault" obj="newDoc" namespaceURI="rootNS"/> |
| <assertTrue actual="isDefault" id="nodeisdefaultnamespace02_true"/> |
| <isDefaultNamespace var="isDefault" obj="newDoc" namespaceURI="nullNSURI"/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace02_false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace03.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace03"> |
| <metadata> |
| <title>nodeisdefaultnamespace03</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on this DocumentType node with the value of the namespaceURI parameter |
| as null check if the value returned is false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <isDefaultNamespace var="isDefault" obj="docType" namespaceURI="nullNSURI"/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace04.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace04"> |
| <metadata> |
| <title>nodeisdefaultnamespace04</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on a Notation and Entity node with the value of the namespaceURI parameter |
| as null check if the value returned is false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entity" type="Entity"/> |
| <var name="notation" type="Notation"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <notations var="notationsMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"alpha"'/> |
| <getNamedItem var="notation" obj="notationsMap" name='"notation1"'/> |
| <isDefaultNamespace var="isDefault" obj="entity" namespaceURI="nullNSURI"/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace04_1"/> |
| <isDefaultNamespace var="isDefault" obj="notation" namespaceURI="nullNSURI"/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace04_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace05.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace05"> |
| <metadata> |
| <title>nodeisdefaultnamespace05</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on a DocumentElement of a new Document node with the value of the |
| namespaceURI parameter equal to the namespaceURI of the newly created Document and check if the |
| value returned is false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <localName var="rootName" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <documentElement var="elem" obj="newDoc"/> |
| <isDefaultNamespace var="isDefault" obj="elem" namespaceURI="rootNS"/> |
| <assertTrue actual="isDefault" id="nodeisdefaultnamespace05_1"/> |
| <isDefaultNamespace var="isDefault" obj="elem" namespaceURI="nullNSURI"/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace05_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace06.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace06"> |
| <metadata> |
| <title>nodeisdefaultnamespace06</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on an Element node with no prefix, which has a namespace |
| attribute declaration with and without a namespace prefix and check if isDefaultNamespace |
| returns true with the namespaceURI that does not have a prefix as its parameter. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="isDefault" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <isDefaultNamespace var="isDefault" obj="elem" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertTrue actual="isDefault" id="nodeisdefaultnamespace06_1"/> |
| <isDefaultNamespace var="isDefault" obj="elem" namespaceURI='"http://www.usa.com"'/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace06_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace07.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace07"> |
| <metadata> |
| <title>nodeisdefaultnamespace07</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on the child of an Element node with no prefix, which has a |
| namespace attribute declaration with and without a namespace prefix and check if isDefaultNamespace |
| returns true with the namespaceURI that does not have a prefix as its parameter. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="isDefault" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <isDefaultNamespace var="isDefault" obj="elem" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertTrue actual="isDefault" id="nodeisdefaultnamespace07_1"/> |
| <isDefaultNamespace var="isDefault" obj="elem" namespaceURI='"http://www.usa.com"'/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace07_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace08.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace08"> |
| <metadata> |
| <title>nodeisdefaultnamespace08</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on an Element node with a prefix, which has a namespace |
| attribute declaration with a namespace prefix and check if isDefaultNamespace |
| returns false with this namespaceURI as its parameter. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="isDefault" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <isDefaultNamespace var="isDefault" obj="elem" namespaceURI='"http://www.altavista.com"'/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace08"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace09.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace09"> |
| <metadata> |
| <title>nodeisdefaultnamespace09</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on a new Child of a new Element node with a namespace URI |
| and prefix and using the parents namespace URI as an argument, verify if the |
| value returned is false. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="Element"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:body"'/> |
| <!-- shouldn't be mixing L1 and L2 calls --> |
| <createElement var="child" obj="doc" tagName='"xhtml:p"'/> |
| <appendChild obj="parent" var="appendedChild" newChild="child"/> |
| <isDefaultNamespace var="isDefault" obj="parent" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace09_1"/> |
| <isDefaultNamespace var="isDefault" obj="child" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace09_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace10.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace10"> |
| <metadata> |
| <title>nodeisdefaultnamespace10</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on a new Child of a new Element node with a namespace URI |
| and prefix and using the childs namespace URI as an argument, verify if the |
| value returned is true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="Element"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:body"'/> |
| <createElementNS var="child" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"'/> |
| <appendChild obj="parent" var="appendedChild" newChild="child"/> |
| <isDefaultNamespace var="isDefault" obj="child" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertTrue actual="isDefault" id="nodeisdefaultnamespace10_1"/> |
| <isDefaultNamespace var="isDefault" obj="parent" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace10_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace11.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace11"> |
| <metadata> |
| <title>nodeisdefaultnamespace11</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on an imported new Element node with a namespace URI and prefix |
| in a new Document and using the parent's namespace URI as an argument, verify if the |
| value returned is true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="importedNode" type="Element"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"'/> |
| <importNode var="importedNode" obj="newDoc" importedNode="elem" deep="true"/> |
| <isDefaultNamespace var="isDefault" obj="importedNode" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertTrue actual="isDefault" id="nodeisdefaultnamespace11"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace13.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace13"> |
| <metadata> |
| <title>nodeisdefaultnamespace13</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on a Element's new Text node, which has a namespace attribute |
| declaration without a namespace prefix in its parent Element node and verify if the |
| value returned is true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="bodyList" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"'/> |
| <createTextNode var="txt" obj="doc" data='"Text"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="txt"/> |
| <appendChild obj="bodyElem" var="appendedChild" newChild="elem"/> |
| <isDefaultNamespace var="isDefault" obj="txt" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertTrue actual="isDefault" id="nodeisdefaultnamespace13"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace14.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace14"> |
| <metadata> |
| <title>nodeisdefaultnamespace14</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on a Element's new CDATASection node, which has a namespace attribute |
| declaration without a namespace prefix in its parent Element node and verify if the |
| value returned is true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="bodyElem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"'/> |
| <createCDATASection var="cdata" obj="doc" data='"CDATASection"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="cdata"/> |
| <appendChild obj="bodyElem" var="appendedChild" newChild="elem"/> |
| <isDefaultNamespace var="isDefault" obj="cdata" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertTrue actual="isDefault" id="nodeisdefaultnamespace14"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace15.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace15"> |
| <metadata> |
| <title>nodeisdefaultnamespace15</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on a Element's new cloned Comment node, which has a namespace attribute |
| declaration without a namespace prefix in its parent Element node and verify if the |
| value returned is true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="bodyElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="comment" type="Comment"/> |
| <var name="clonedComment" type="Comment"/> |
| <var name="isDefault" type="boolean"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="bodyList" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"'/> |
| <createComment var="comment" obj="doc" data='"Text"'/> |
| <cloneNode var="clonedComment" obj="comment" deep="true"/> |
| <appendChild obj="elem" var="appendedChild" newChild="clonedComment"/> |
| <appendChild obj="bodyElem" var="appendedChild" newChild="elem"/> |
| <isDefaultNamespace var="isDefault" obj="clonedComment" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertTrue actual="isDefault" id="nodeisdefaultnamespace15"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisdefaultnamespace16.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisdefaultnamespace16"> |
| <metadata> |
| <title>nodeisdefaultnamespace16</title> |
| <creator>IBM</creator> |
| <description> |
| Using isDefaultNamespace on a new Attribute node with with a namespace URI |
| and no prefix and verify if the value returned is false since default namespaces |
| do not apply directly to attributes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isDefaultNamespace"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr" type="Attr"/> |
| <var name="isDefault" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"lang"'/> |
| <isDefaultNamespace var="isDefault" obj="attr" namespaceURI='"http://www.w3.org/XML/1998/namespace"'/> |
| <assertFalse actual="isDefault" id="nodeisdefaultnamespace16"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode01.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode01"> |
| <metadata> |
| <title>nodeisequalnode01</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 Document nodes created by parsing the same xml document |
| are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <load var="doc2" href="hc_staff" willBeModified="false"/> |
| <isEqualNode var="isEqual" obj="doc1" arg="doc2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode02.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode02"> |
| <metadata> |
| <title>nodeisequalnode02</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 newly created Document nodes having the same namespaceURI |
| and qualifiedName are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="doc1" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createDocument var="doc2" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <isEqualNode var="isEqual" obj="doc1" arg="doc2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode03.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode03"> |
| <metadata> |
| <title>nodeisequalnode03</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 Document nodes created by parsing |
| documents only differing in declared encoding return false for isEqualNode on |
| the document and true on the document element. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=528"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="docElem1" type="Element"/> |
| <var name="docElem2" type="Element"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc1" href="barfoo_utf8" willBeModified="false"/> |
| <load var="doc2" href="barfoo_utf16" willBeModified="false"/> |
| <isEqualNode var="isEqual" obj="doc1" arg="doc2"/> |
| <!-- encoding is not significant in equality --> |
| <assertTrue actual="isEqual" id="docAreNotEquals"/> |
| <documentElement var="docElem1" obj="doc1"/> |
| <documentElement var="docElem2" obj="doc2"/> |
| <isEqualNode var="isEqual" obj="docElem1" arg="docElem2"/> |
| <assertTrue actual="isEqual" id="docElemsAreEquals"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode04.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode04"> |
| <metadata> |
| <title>nodeisequalnode04</title> |
| <creator>IBM</creator> |
| <description> |
| Create a new Element node in this Document. return its ownerDocument and check if the |
| the ownerDocument is equal to this Document using isEqualNode. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="ownerDoc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:p"'/> |
| <ownerDocument var="ownerDoc" obj="elem"/> |
| <isEqualNode var="isEqual" obj="doc" arg="ownerDoc"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode05.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode05"> |
| <metadata> |
| <title>nodeisequalnode05</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 Document nodes created by parsing different xml document |
| are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc1" href="barfoo_standalone_yes" willBeModified="false"/> |
| <load var="doc2" href="barfoo" willBeModified="false"/> |
| <isEqualNode var="isEqual" obj="doc1" arg="doc2"/> |
| <assertFalse actual="isEqual" id="nodeisequalnode05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode06.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode06"> |
| <metadata> |
| <title>nodeisequalnode06</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 Element nodes having the same nodeName and namespaceURI attribute |
| are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem1" type="Element"/> |
| <var name="elem2" type="Element"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="elem1" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:html"'/> |
| <createElementNS var="elem2" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:html"'/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode06"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode07.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode07"> |
| <metadata> |
| <title>nodeisequalnode07</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 Element nodes having the same nodeName and namespaceURI attribute |
| created by two different Document objects obtained by parsing the same xml document are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="elem1" type="Element"/> |
| <var name="elem2" type="Element"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <load var="doc2" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="elem1" obj="doc1" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:html"'/> |
| <createElementNS var="elem2" obj="doc2" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:html"'/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode07"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode08.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode08"> |
| <metadata> |
| <title>nodeisequalnode08</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive an element node of this Document having nodeName as employeeId and |
| namespaceURI as http://www.nist.gov. Create a new Element node having the same attributes |
| in this Document and using isEqualNode check if 2 Element nodes are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="ignoringElementContentWhitespace" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem1" type="Element"/> |
| <var name="elem2" type="Element"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="text" type="Text"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="employeeList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem1" obj="employeeList" index="0" interface="NodeList"/> |
| <createElementNS var="elem2" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"em"'/> |
| <createTextNode var="text" obj="doc" data='"EMP0001"'/> |
| <appendChild obj="elem2" var="appendedChild" newChild="text"/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode08"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode09.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode09"> |
| <metadata> |
| <title>nodeisequalnode09</title> |
| <creator>IBM</creator> |
| <description> |
| Get the first "em" node, construct an equivalent in a new document and see if isEqualNode |
| returns true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="ignoringElementContentWhitespace" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="elem1" type="Element"/> |
| <var name="elem2" type="Element"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="text" type="Text"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <localName var="rootName" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='rootNS' qualifiedName='rootName' doctype="nullDocType"/> |
| <getElementsByTagName var="employeeList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem1" obj="employeeList" index="0" interface="NodeList"/> |
| <createElementNS var="elem2" obj="newDoc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"em"'/> |
| <createTextNode var="text" obj="newDoc" data='"EMP0001"'/> |
| <appendChild obj="elem2" var="appendedChild" newChild="text"/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem2"/> |
| <assertTrue actual="isEqual" id="nodesAreEqual"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode10.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode10"> |
| <metadata> |
| <title>nodeisequalnode10</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive 2 different "em" nodes of this Document Use isEqualNode |
| check if nodes are not equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem1" type="Element"/> |
| <var name="elem2" type="Element"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="employeeList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem1" obj="employeeList" index="0" interface="NodeList"/> |
| <item var="elem2" obj="employeeList" index="1" interface="NodeList"/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem2"/> |
| <assertFalse actual="isEqual" id="nodeisequalnode10"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode11.xml |
|---|
| 0,0 → 1,76 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode11"> |
| <metadata> |
| <title>nodeisequalnode11</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive the first element node whose localName is "p". Import it into a new |
| Document with deep=false. Using isEqualNode check if the original and the imported |
| Element Node are not equal the child nodes are different. |
| Import with deep and the should still be unequal if |
| validating since the |
| new document does not provide the same default attributes. |
| Import it into another instance of the source document |
| and then the imported node and the source should be equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=529"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="newDoc" type="Document"/> |
| <var name="dupDoc" type="Document"/> |
| <var name="elem1" type="Element"/> |
| <var name="elem2" type="Element"/> |
| <var name="elem3" type="Element"/> |
| <var name="elem4" type="Element"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='rootNS' qualifiedName='rootName' doctype="nullDocType"/> |
| <getElementsByTagName var="employeeList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem1" obj="employeeList" index="0" interface="NodeList"/> |
| <importNode var="elem2" obj="newDoc" importedNode="elem1" deep="false"/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem2"/> |
| <assertFalse actual="isEqual" id="nodeisequalnodeFalse11"/> |
| <importNode var="elem3" obj="newDoc" importedNode="elem1" deep="true"/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem3"/> |
| <!-- if validating the nodes should be unequal |
| since the new node will not contain |
| default attributes. Unable to make a statement |
| when not validating --> |
| <if><implementationAttribute name="validating" value="true"/> |
| <assertFalse actual="isEqual" id="deepImportNoDTD"/> |
| </if> |
| <load var="dupDoc" href="hc_staff" willBeModified="true"/> |
| <importNode var="elem4" obj="dupDoc" importedNode="elem1" deep="true"/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem4"/> |
| <assertTrue actual="isEqual" id="deepImportSameDTD"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode12.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode12"> |
| <metadata> |
| <title>nodeisequalnode12</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqual verify if the 2 documentElement nodes of different documents created |
| by parsing the same xml document are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem1" type="Element"/> |
| <var name="elem2" type="Element"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="elem1" obj="doc"/> |
| <documentElement var="elem2" obj="doc"/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode12"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode13.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode13"> |
| <metadata> |
| <title>nodeisequalnode13</title> |
| <creator>IBM</creator> |
| <description> |
| Retreive the first element node whose localName is "p". Import it into a new |
| Document with deep=false. Using isEqualNode check if the original and the imported |
| Element Node are not equal. Now import it once more with deep=true and using isEqual |
| verify if they are now equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="employeeList" type="NodeList"/> |
| <var name="elem1" type="Element"/> |
| <var name="elem2" type="Element"/> |
| <var name="elem3" type="Element"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <getElementsByTagName var="employeeList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem1" obj="employeeList" index="0" interface="NodeList"/> |
| <cloneNode var="elem2" obj="elem1" deep="false"/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem2"/> |
| <assertFalse actual="isEqual" id="nodeisequalnodeFalse13"/> |
| <cloneNode var="elem3" obj="elem1" deep="true"/> |
| <isEqualNode var="isEqual" obj="elem1" arg="elem3"/> |
| <assertTrue actual="isEqual" id="nodeisequalnodeTrue13"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode14.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode14"> |
| <metadata> |
| <title>nodeisequalnode14</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 Attr nodes having the same nodeName and a null namespaceURI |
| attribute, one created using createAttribute and the other createAttributeNS, are not equal. |
| Note the localName for an Attr created with DOM Level 1 methods is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr1" type="Attr"/> |
| <var name="attr2" type="Attr"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createAttribute var="attr1" obj="doc" name='"root"'/> |
| <createAttributeNS var="attr2" obj="doc" namespaceURI="nullNSURI" qualifiedName='"root"'/> |
| <isEqualNode var="isEqual" obj="attr1" arg="attr2"/> |
| <assertFalse actual="isEqual" id="nodeisequalnode14"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode15.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode15"> |
| <metadata> |
| <title>nodeisequalnode15</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 Attr nodes having the same nodeName and a null namespaceURI |
| attribute, one created using createAttributeNS and the other retreived from this document |
| are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr1" type="Attr"/> |
| <var name="attr2" type="Attr"/> |
| <var name="addrElement" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"acronym"' var="elementList"/> |
| <item interface="NodeList" obj="elementList" var="addrElement" index="3" /> |
| <getAttributeNodeNS obj="addrElement" var="attr1" namespaceURI='nullNS' localName='"title"'/> |
| <if><implementationAttribute name="namespaceAware" value="true"/> |
| <createAttributeNS var="attr2" obj="doc" namespaceURI='nullNS' qualifiedName='"title"'/> |
| <else> |
| <createAttribute var="attr2" obj="doc" name='"title"'/> |
| </else> |
| </if> |
| <value obj="attr2" value='"Yes"'/> |
| <isEqualNode var="isEqual" obj="attr1" arg="attr2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode15"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode16.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode16"> |
| <metadata> |
| <title>nodeisequalnode16</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if a default attribute node and a cloned default attribute |
| node are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr1" type="Attr"/> |
| <var name="attr2" type="Attr"/> |
| <var name="addrElement" type="Element"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elementList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="addrElement" obj="elementList" index="3" interface="NodeList"/> |
| <getAttributeNodeNS obj="addrElement" var="attr1" namespaceURI="nullNSURI" localName='"dir"'/> |
| <cloneNode var="attr2" obj="attr1" deep="true"/> |
| <isEqualNode var="isEqual" obj="attr1" arg="attr2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode16"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode17.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode17"> |
| <metadata> |
| <title>nodeisequalnode17</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if a new Attr node created in this Document is equal to |
| the imported node returned when it is imported into a new Document. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="attr1" type="Attr"/> |
| <var name="attr2" type="Attr"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createAttributeNS var="attr1" obj="doc" namespaceURI="nullNSURI" qualifiedName='"root"'/> |
| <importNode var="attr2" obj="newDoc" importedNode="attr1" deep="true"/> |
| <isEqualNode var="isEqual" obj="attr1" arg="attr2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode17"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode18.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode18"> |
| <metadata> |
| <title>nodeisequalnode18</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if a new Attr node created in this Document is equal to |
| the attr node adopted by a new document. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="attr1" type="Attr"/> |
| <var name="attr2" type="Attr"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createAttributeNS var="attr1" obj="doc" namespaceURI="nullNSURI" qualifiedName='"title"'/> |
| <adoptNode var="attr2" obj="newDoc" source="attr1" /> |
| <if><notNull obj="attr2"/> |
| <isEqualNode var="isEqual" obj="attr1" arg="attr2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode18"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode19.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode19"> |
| <metadata> |
| <title>nodeisequalnode19</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 Attr nodes having the same nodeName but different namespaceURIs |
| are not equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr1" type="Attr"/> |
| <var name="attr2" type="Attr"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createAttributeNS var="attr1" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"lang"'/> |
| <createAttributeNS var="attr2" obj="doc" namespaceURI="nullNSURI" qualifiedName='"lang"'/> |
| <isEqualNode var="isEqual" obj="attr1" arg="attr2"/> |
| <assertFalse actual="isEqual" id="nodeisequalnode19"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode20.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode20"> |
| <metadata> |
| <title>nodeisequalnode20</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if an Element and an Attr nodes having the same nodeName |
| and namsepaceURI are not equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="attr1" type="Attr"/> |
| <var name="elem1" type="Element"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="elem1" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:html"'/> |
| <createAttributeNS var="attr1" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:html"'/> |
| <isEqualNode var="isEqual" obj="attr1" arg="elem1"/> |
| <assertFalse actual="isEqual" id="nodeisequalnode20"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode21.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode21"> |
| <metadata> |
| <title>nodeisequalnode21</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 DocumentType nodes returned by parsing the same xml document |
| are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="docType1" type="DocumentType"/> |
| <var name="docType2" type="DocumentType"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <load var="doc2" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType1" obj="doc1"/> |
| <doctype var="docType2" obj="doc2"/> |
| <isEqualNode var="isEqual" obj="docType1" arg="docType2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode21"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode22.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode22"> |
| <metadata> |
| <title>nodeisequalnode22</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 new DocumentType having null public and system ids |
| are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="domImpl1" type="DOMImplementation"/> |
| <var name="domImpl2" type="DOMImplementation"/> |
| <var name="docType1" type="DocumentType"/> |
| <var name="docType2" type="DocumentType"/> |
| <var name="isEqual" type="boolean"/> |
| <var name="nullPubId" type="DOMString" isNull="true"/> |
| <var name="nullSysId" type="DOMString" isNull="true"/> |
| <var name="oldDocType" type="DocumentType"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc1" href="barfoo" willBeModified="false"/> |
| <doctype var="oldDocType" obj="doc1"/> |
| <name var="rootName" obj="oldDocType" interface="DocumentType"/> |
| <load var="doc2" href="barfoo" willBeModified="false"/> |
| <implementation var="domImpl1" obj="doc1"/> |
| <implementation var="domImpl2" obj="doc2"/> |
| <createDocumentType var="docType1" obj="domImpl1" qualifiedName="rootName" publicId="nullPubId" systemId="nullSysId"/> |
| <createDocumentType var="docType2" obj="domImpl2" qualifiedName="rootName" publicId="nullPubId" systemId="nullSysId"/> |
| <isEqualNode var="isEqual" obj="docType1" arg="docType2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode22"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode25.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode25"> |
| <metadata> |
| <title>nodeisequalnode25</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 EntityNode having the same name of two DocumentType nodes |
| returned by parsing the same xml document are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="docType1" type="DocumentType"/> |
| <var name="docType2" type="DocumentType"/> |
| <var name="entitiesMap1" type="NamedNodeMap"/> |
| <var name="entitiesMap2" type="NamedNodeMap"/> |
| <var name="alpha" type="Entity"/> |
| <var name="beta" type="Entity"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <load var="doc2" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType1" obj="doc1"/> |
| <doctype var="docType2" obj="doc2"/> |
| <entities var="entitiesMap1" obj="docType1"/> |
| <entities var="entitiesMap2" obj="docType2"/> |
| <getNamedItem var="alpha" obj="entitiesMap1" name='"delta"'/> |
| <getNamedItem var="beta" obj="entitiesMap2" name='"delta"'/> |
| <isEqualNode var="isEqual" obj="alpha" arg="beta"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode25"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode26.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode26"> |
| <metadata> |
| <title>nodeisequalnode26</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 NotationNode having the same name of two DocumnotationType nodes |
| returned by parsing the same xml documnotation are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="docType1" type="DocumentType"/> |
| <var name="docType2" type="DocumentType"/> |
| <var name="notationsMap1" type="NamedNodeMap"/> |
| <var name="notationsMap2" type="NamedNodeMap"/> |
| <var name="notation1" type="Notation"/> |
| <var name="notation2" type="Notation"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <load var="doc2" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType1" obj="doc1"/> |
| <doctype var="docType2" obj="doc2"/> |
| <notations var="notationsMap1" obj="docType1"/> |
| <notations var="notationsMap2" obj="docType2"/> |
| <getNamedItem var="notation1" obj="notationsMap1" name='"notation1"'/> |
| <getNamedItem var="notation2" obj="notationsMap2" name='"notation1"'/> |
| <isEqualNode var="isEqual" obj="notation1" arg="notation2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnode26"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode27.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode27"> |
| <metadata> |
| <title>nodeisequalnode27</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 EntityNode having the same name of two DocumentType nodes |
| returned by parsing the same xml document are equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="alpha" type="Entity"/> |
| <var name="notation1" type="Notation"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <notations var="notationsMap" obj="docType"/> |
| <getNamedItem var="alpha" obj="entitiesMap" name='"alpha"'/> |
| <getNamedItem var="notation1" obj="notationsMap" name='"notation1"'/> |
| <isEqualNode var="isEqual" obj="notation1" arg="alpha"/> |
| <assertFalse actual="isEqual" id="nodeisequalnode27"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode28.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode28"> |
| <metadata> |
| <title>nodeisequalnode28</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 new Text nodes having null text are equal and two others |
| having different data are not equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="text1" type="Text"/> |
| <var name="text2" type="Text"/> |
| <var name="text3" type="Text"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createTextNode var="text1" obj="doc" data='""'/> |
| <createTextNode var="text2" obj="doc" data='""'/> |
| <createTextNode var="text3" obj="doc" data='"#Text"'/> |
| <isEqualNode var="isEqual" obj="text1" arg="text2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnodeTrue28"/> |
| <isEqualNode var="isEqual" obj="text1" arg="text3"/> |
| <assertFalse actual="isEqual" id="nodeisequalnodeFalse28"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode29.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="comment/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode29"> |
| <metadata> |
| <title>nodeisequalnode29</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 new Comment nodes having the same data are equal and two others |
| having different data are not equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="comment1" type="Comment"/> |
| <var name="comment2" type="Comment"/> |
| <var name="comment3" type="Comment"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createComment var="comment1" obj="doc" data='"comment"'/> |
| <createComment var="comment2" obj="doc" data='"comment"'/> |
| <createComment var="comment3" obj="doc" data='"#Comment"'/> |
| <isEqualNode var="isEqual" obj="comment1" arg="comment2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnodeTrue29"/> |
| <isEqualNode var="isEqual" obj="comment1" arg="comment3"/> |
| <assertFalse actual="isEqual" id="nodeisequalnodeFalse29"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode31.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="cdata/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode31"> |
| <metadata> |
| <title>nodeisequalnode31</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 new CDATASection nodes having the same data are equal and two others |
| having different data are not equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="cdata1" type="CDATASection"/> |
| <var name="cdata2" type="CDATASection"/> |
| <var name="cdata3" type="CDATASection"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createCDATASection var="cdata1" obj="doc" data='"cdata"'/> |
| <createCDATASection var="cdata2" obj="doc" data='"cdata"'/> |
| <createCDATASection var="cdata3" obj="doc" data='"#CDATASection"'/> |
| <isEqualNode var="isEqual" obj="cdata1" arg="cdata2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnodeTrue29"/> |
| <isEqualNode var="isEqual" obj="cdata1" arg="cdata3"/> |
| <assertFalse actual="isEqual" id="nodeisequalnodeFalse29"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeisequalnode32.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="pi/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeisequalnode32"> |
| <metadata> |
| <title>nodeisequalnode32</title> |
| <creator>IBM</creator> |
| <description> |
| Using isEqualNode check if 2 new ProcessingInstruction nodes having the same data are equal and two others |
| having different data are not equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isEqualNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="pi1" type="ProcessingInstruction"/> |
| <var name="pi2" type="ProcessingInstruction"/> |
| <var name="pi3" type="ProcessingInstruction"/> |
| <var name="isEqual" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createProcessingInstruction var="pi1" obj="doc" data='"pi"' target='"Target1"'/> |
| <createProcessingInstruction var="pi2" obj="doc" data='"pi"' target='"Target1"'/> |
| <createProcessingInstruction var="pi3" obj="doc" data='"#ProcessingInstruction"' target='"Target1"'/> |
| <isEqualNode var="isEqual" obj="pi1" arg="pi2"/> |
| <assertTrue actual="isEqual" id="nodeisequalnodeTrue29"/> |
| <isEqualNode var="isEqual" obj="pi1" arg="pi3"/> |
| <assertFalse actual="isEqual" id="nodeisequalnodeFalse29"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeissamenode01.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeissamenode01"> |
| <metadata> |
| <title>nodeissamenode01</title> |
| <creator>IBM</creator> |
| <description> |
| Using isSameNode to check if 2 Document nodes that are equal but do not reference the |
| same object are not the same |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isSameNode"/> |
| </metadata> |
| <var name="doc1" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="isSame" type="boolean"/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <load var="doc2" href="hc_staff" willBeModified="false"/> |
| <isSameNode var="isSame" obj="doc1" other="doc2"/> |
| <assertFalse actual="isSame" id="nodeissamenode01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeissamenode02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeissamenode02"> |
| <metadata> |
| <title>nodeissamenode02</title> |
| <creator>IBM</creator> |
| <description> |
| Using isSameNode check if 2 DocumentType nodes that reference the same object are |
| the same. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isSameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType1" type="DocumentType"/> |
| <var name="docType2" type="DocumentType"/> |
| <var name="isSame" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType1" obj="doc"/> |
| <doctype var="docType2" obj="doc"/> |
| <isSameNode var="isSame" obj="docType1" other="docType2"/> |
| <assertTrue actual="isSame" id="nodeissamenode02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeissamenode03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeissamenode03"> |
| <metadata> |
| <title>nodeissamenode03</title> |
| <creator>IBM</creator> |
| <description> |
| Using isSameNode check if 2 Element nodes that reference the same object are |
| the same. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isSameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element1" type="Element"/> |
| <var name="element2" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="isSame" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="element1" obj="childList" index="0" interface="NodeList"/> |
| <item var="element2" obj="childList" index="0" interface="NodeList"/> |
| <isSameNode var="isSame" obj="element2" other="element1"/> |
| <assertTrue actual="isSame" id="nodeissamenode03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeissamenode04.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeissamenode04"> |
| <metadata> |
| <title>nodeissamenode04</title> |
| <creator>IBM</creator> |
| <description> |
| Using isSameNode check if 2 Element nodes that are equal but do not reference the |
| same object are not the same. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isSameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element1" type="Element"/> |
| <var name="element2" type="Element"/> |
| <var name="isSame" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="element1" obj="doc" qualifiedName='"xhtml:br"' namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <createElementNS var="element2" obj="doc" qualifiedName='"xhtml:br"' namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <isSameNode var="isSame" obj="element2" other="element1"/> |
| <assertFalse actual="isSame" id="nodeissamenode04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeissamenode05.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeissamenode05"> |
| <metadata> |
| <title>nodeissamenode05</title> |
| <creator>IBM</creator> |
| <description> |
| Using isSameNode check if 2 Document Element nodes that reference the same object are |
| the same. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isSameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element1" type="Element"/> |
| <var name="element2" type="Element"/> |
| <var name="isSame" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="element1" obj="doc"/> |
| <documentElement var="element2" obj="doc"/> |
| <isSameNode var="isSame" obj="element2" other="element1"/> |
| <assertTrue actual="isSame" id="nodeissamenode05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeissamenode06.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeissamenode06"> |
| <metadata> |
| <title>nodeissamenode06</title> |
| <creator>IBM</creator> |
| <description> |
| Using isSameNode check if 2 Document Element nodes that reference the same object are |
| the same. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isSameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="element" type="Element"/> |
| <var name="element1" type="Element"/> |
| <var name="attr1" type="Attr"/> |
| <var name="attr2" type="Attr"/> |
| <var name="childList" type="NodeList"/> |
| <var name="isSame" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="element" obj="childList" index="2" interface="NodeList"/> |
| <item var="element1" obj="childList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr1" obj="element" name='"class"'/> |
| <getAttributeNode var="attr2" obj="element1" name='"class"'/> |
| <isSameNode var="isSame" obj="attr1" other="attr2"/> |
| <assertTrue actual="isSame" id="nodeissamenode06"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeissamenode07.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeissamenode07"> |
| <metadata> |
| <title>nodeissamenode07</title> |
| <creator>IBM</creator> |
| <description> |
| Using isSameNode check if 2 Entity nodes that reference the same object are |
| the same. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isSameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity1" type="Entity"/> |
| <var name="entity2" type="Entity"/> |
| <var name="isSame" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity1" obj="entitiesMap" name='"delta"'/> |
| <getNamedItem var="entity2" obj="entitiesMap" name='"delta"'/> |
| <isSameNode var="isSame" obj="entity1" other="entity2"/> |
| <assertTrue actual="isSame" id="nodeissamenode07"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeissamenode08.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeissamenode08"> |
| <metadata> |
| <title>nodeissamenode08</title> |
| <creator>IBM</creator> |
| <description> |
| Using isSameNode check if 2 Notation nodes that reference the same object are |
| the same. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isSameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="notation1" type="Notation"/> |
| <var name="notation2" type="Notation"/> |
| <var name="isSame" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="entitiesMap" obj="docType"/> |
| <getNamedItem var="notation1" obj="entitiesMap" name='"notation1"'/> |
| <getNamedItem var="notation2" obj="entitiesMap" name='"notation1"'/> |
| <isSameNode var="isSame" obj="notation1" other="notation2"/> |
| <assertTrue actual="isSame" id="nodeissamenode08"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeissamenode09.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeissamenode09"> |
| <metadata> |
| <title>nodeissamenode09</title> |
| <creator>IBM</creator> |
| <description> |
| Using isSameNode check if an Entity and its docType nodes are not the same. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isSameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="isSame" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"alpha"'/> |
| <isSameNode var="isSame" obj="docType" other="entity"/> |
| <assertFalse actual="isSame" id="nodeissamenode09"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodeissamenode10.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeissamenode10"> |
| <metadata> |
| <title>nodeissamenode10</title> |
| <creator>IBM</creator> |
| <description> |
| Using isSameNode check if an new Document and a new Element node are not the same. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-isSameNode"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="element" type="Element"/> |
| <var name="isSame" type="boolean"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createElementNS var="element" obj="newDoc" namespaceURI="rootNS" qualifiedName="rootName"/> |
| <isSameNode var="isSame" obj="newDoc" other="element"/> |
| <assertFalse actual="isSame" id="nodeissamenode10"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri01.xml |
|---|
| 0,0 → 1,37 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri01"> |
| <metadata> |
| <title>nodelookupnamespaceuri01</title> |
| <creator>IBM</creator> |
| <description> |
| Return value from lookupNamespaceURI(null) on a Document node with no default namespace should be null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="nullPrefix" type="DOMString" isNull="true"/> |
| <load var="doc" href="barfoo_nodefaultns" willBeModified="false"/> |
| <lookupNamespaceURI var="namespaceURI" obj="doc" prefix="nullPrefix" interface="Node"/> |
| <assertNull actual="namespaceURI" id="nodelookupnamespaceuri01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri02.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri02"> |
| <metadata> |
| <title>nodelookupnamespaceuri02</title> |
| <creator>IBM</creator> |
| <description> |
| Using lookupNamespaceURI on a new Document node with a namespaceURI and prefix |
| and check if the value returned is the same namespaceURI. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="qname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <plus var="qname" op1='"dom3:"' op2="rootName"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="qname" doctype="nullDocType"/> |
| <lookupNamespaceURI var="namespaceURI" obj="newDoc" prefix='"dom3"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected="rootNS" id="nodelookupnamespaceuri02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri03"> |
| <metadata> |
| <title>nodelookupnamespaceuri03</title> |
| <creator>IBM</creator> |
| <description> |
| Using lookupNamespaceURI on this DocumentType node check if the value returned is Null . |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="nullPrefix" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <lookupNamespaceURI var="namespaceURI" obj="docType" prefix="nullPrefix" interface="Node"/> |
| <assertNull actual="namespaceURI" id="nodelookupnamespaceuri03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri04.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri04"> |
| <metadata> |
| <title>nodelookupnamespaceuri04</title> |
| <creator>IBM</creator> |
| <description> |
| Using lookupNamespaceURI on an Entity and Notation node and check if the value returned is Null . |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entity" type="Entity"/> |
| <var name="notation" type="Notation"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <notations var="notationsMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"alpha"'/> |
| <getNamedItem var="notation" obj="notationsMap" name='"notation1"'/> |
| <lookupNamespaceURI var="namespaceURI" obj="entity" prefix='""' interface="Node"/> |
| <assertNull actual="namespaceURI" id="nodelookupnamespaceuri04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri05.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri05"> |
| <metadata> |
| <title>nodelookupnamespaceuri05</title> |
| <creator>IBM</creator> |
| <description> |
| Using lookupNamespaceURI on the DocumentElement node of a new document with a |
| namespaceURI and prefix and check if the namespaceURI value returned is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="qname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <plus var="qname" op1='"dom3:"' op2="rootName"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="qname" doctype="nullDocType"/> |
| <documentElement var="elem" obj="newDoc"/> |
| <lookupNamespaceURI var="namespaceURI" obj="elem" prefix='"dom3"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected="rootNS" id="nodelookupnamespaceuri05" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri06.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri06"> |
| <metadata> |
| <title>nodelookupnamespaceuri06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on an Element node with no prefix, which has a namespace |
| attribute declaration with a namespace prefix and check if the value of the namespaceURI |
| returned by using its prefix as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="2" interface="NodeList"/> |
| <lookupNamespaceURI var="namespaceURI" obj="elem" prefix='"dmstc"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.netzero.com"' id="nodelookupnamespaceuri06" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri07.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri07"> |
| <metadata> |
| <title>nodelookupnamespaceuri07</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on an Element node with no prefix, which has a namespace |
| attribute declaration with a namespace prefix in its parent Element node and check if |
| the value of the namespaceURI returned by using its prefix as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="2" interface="NodeList"/> |
| <lookupNamespaceURI var="namespaceURI" obj="elem" prefix='"dmstc"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.netzero.com"' id="nodelookupnamespaceuri07" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri08.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri08"> |
| <metadata> |
| <title>nodelookupnamespaceuri08</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on an Element node with no prefix, which has 2 namespace |
| attribute declarations with and without namespace prefixes and check if the value of the prefix |
| returned by using a valid prefix and an empty prefix as a parameter is a valid |
| namespaceURI or null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="namespaceURIEmpty" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <lookupNamespaceURI var="namespaceURI" obj="elem" prefix='"dmstc"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.usa.com"' id="nodelookupnamespaceuri08" ignoreCase="false"/> |
| <lookupNamespaceURI var="namespaceURIEmpty" obj="elem" prefix='""' interface="Node"/> |
| <assertNull actual="namespaceURIEmpty" id="nodelookupnamespaceprefixEmpty08"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri09.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri09"> |
| <metadata> |
| <title>nodelookupnamespaceuri09</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on an Element node with no prefix, whose parent has no prefix and |
| 2 namespace attribute declarations with and without namespace prefixes and check if the value of |
| the namespaceURI returned by using each prefix as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="namespaceURIEmpty" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <lookupNamespaceURI var="namespaceURI" obj="elem" prefix='"dmstc"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.usa.com"' id="nodelookupnamespaceuri09" ignoreCase="false"/> |
| <lookupNamespaceURI var="namespaceURIEmpty" obj="elem" prefix='""' interface="Node"/> |
| <assertNull actual="namespaceURIEmpty" id="nodelookupnamespaceprefixEmpty09"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri10.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri10"> |
| <metadata> |
| <title>nodelookupnamespaceuri10</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on a new Child of a new Element node with a namespace URI |
| and prefix and using the parents prefix as an argument, verify if the namespaceURI |
| returned is a valid namespaceURI for the parent. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="Element"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:body"'/> |
| <createElement var="child" obj="doc" tagName='"p"'/> |
| <appendChild obj="parent" var="appendedChild" newChild="child"/> |
| <lookupNamespaceURI var="namespaceURI" obj="child" prefix='"xhtml"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.w3.org/1999/xhtml"' id="nodelookupnamespaceuri10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri11.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri11"> |
| <metadata> |
| <title>nodelookupnamespaceuri11</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on an imported new Element node with a namespace URI and prefix |
| in a new Document and using the parents prefix as an argument, verify if the namespaceURI |
| returned is a valid namespaceURI of the parent. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="importedNode" type="Element"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <importNode var="importedNode" obj="newDoc" importedNode="elem" deep="true"/> |
| <lookupNamespaceURI var="namespaceURI" obj="importedNode" prefix='"dom3"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.w3.org/1999/xhtml"' id="nodelookupnamespaceuri11" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri13.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri13"> |
| <metadata> |
| <title>nodelookupnamespaceuri13</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on a Element's new Text node, which has a namespace attribute declaration |
| with a namespace prefix in its parent Element node and check if the value of the namespaceURI |
| returned by using its prefix as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createTextNode var="txt" obj="doc" data='"Text"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="txt"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="elem"/> |
| <lookupNamespaceURI var="namespaceURI" obj="txt" prefix='"dom3"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.w3.org/1999/xhtml"' id="nodelookupnamespaceuri13" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri14.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri14"> |
| <metadata> |
| <title>nodelookupnamespaceuri14</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on a Element's new Text node, which has a namespace attribute declaration |
| with a namespace prefix in its parent Element node and check if the value of the namespaceURI |
| returned by using its prefix as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="lookupNamespaceURI" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createCDATASection var="cdata" obj="doc" data='"Text"'/> |
| <appendChild var="appendedChild" obj="elem" newChild="cdata"/> |
| <appendChild var="appendedChild" obj="docElem" newChild="elem"/> |
| <lookupNamespaceURI var="lookupNamespaceURI" obj="cdata" prefix='"dom3"' interface="Node"/> |
| <assertEquals actual="lookupNamespaceURI" expected='"http://www.w3.org/1999/xhtml"' id="nodelookupnamespaceuri14" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri15.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri15"> |
| <metadata> |
| <title>nodelookupnamespaceuri15</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on a Element's new Comment node, which has a namespace attribute declaration |
| with a namespace prefix in its parent Element node and check if the value of the namespaceURI |
| returned by using its prefix as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="comment" type="Comment"/> |
| <var name="clonedComment" type="Comment"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createComment var="comment" obj="doc" data='"Text"'/> |
| <cloneNode var="clonedComment" obj="comment" deep="true"/> |
| <appendChild obj="elem" var="appendedChild" newChild="clonedComment"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="elem"/> |
| <lookupNamespaceURI var="namespaceURI" obj="clonedComment" prefix='"dom3"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.w3.org/1999/xhtml"' id="nodelookupnamespaceuri15" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri16.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri16"> |
| <metadata> |
| <title>nodelookupnamespaceuri16</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on a new Attribute node with with a namespace URI |
| and prefix and verify if the namespaceURI returned is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="attNode" type="Attr"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <setAttributeNodeNS obj="elem" var="attNode" newAttr="attr"/> |
| <lookupNamespaceURI var="namespaceURI" obj="attr" prefix='"xml"' interface="Node"/> |
| <assertNull actual="namespaceURI" id="nodelookupnamespaceuri16"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri17.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri17"> |
| <metadata> |
| <title>nodelookupnamespaceuri17</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on the title attribute node of the acronym node with |
| a namespaceURI and a node prefix and check if the value of the namespaceURI returned by |
| using its prefix as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="2" interface="NodeList"/> |
| <attributes var="attributesMap" obj="elem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xsi:noNamespaceSchemaLocation"'/> |
| <lookupNamespaceURI var="namespaceURI" obj="attr" prefix='"dmstc"' interface="Node" /> |
| <assertEquals actual="namespaceURI" expected='"http://www.netzero.com"' id="nodelookupnamespaceuri17" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri18.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri18"> |
| <metadata> |
| <title>nodelookupnamespaceuri18</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on the default attribute node of the p node with |
| a namespaceURI and a node prefix and check if the value of the namespaceURI returned by |
| using its prefix as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <attributes var="attributesMap" obj="elem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"dir"'/> |
| <lookupNamespaceURI var="namespaceURI" obj="attr" prefix='"nm"' interface="Node" /> |
| <assertEquals actual="namespaceURI" expected='"http://www.altavista.com"' id="nodelookupnamespaceuri18" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri19.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri19"> |
| <metadata> |
| <title>nodelookupnamespaceuri19</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on the an attribute node without a namespace prefix of |
| an Element node that has a namespaceURI and prefix, and check if the value of the namespaceURI |
| returned by using the Elements prefix as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <attributes var="attributesMap" obj="elem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <lookupNamespaceURI var="namespaceURI" obj="attr" prefix='"xsi"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.w3.org/2001/XMLSchema-instance"' id="nodelookupnamespaceuri19" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupnamespaceuri20.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupnamespaceuri20"> |
| <metadata> |
| <title>nodelookupnamespaceuri20</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupNamespaceURI on the an attribute node without a namespace prefix of |
| an Element node that has a namespaceURI and prefix, and check if the value of the namespaceURI |
| returned by using the Elements prefix as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespaceURI"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <attributes var="attributesMap" obj="elem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:nm"'/> |
| <lookupNamespaceURI var="namespaceURI" obj="attr" prefix='"nm"' interface="Node"/> |
| <assertEquals actual="namespaceURI" expected='"http://www.altavista.com"' id="nodelookupnamespaceuri20" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix01.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix01"> |
| <metadata> |
| <title>nodelookupprefix01</title> |
| <creator>IBM</creator> |
| <description> |
| Using lookupPrefix on this Document node check if the value returned is Null . |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <lookupPrefix var="prefix" obj="doc" namespaceURI="nullNSURI"/> |
| <assertNull actual="prefix" id="nodelookupprefix01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix02.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix02"> |
| <metadata> |
| <title>nodelookupprefix02</title> |
| <creator>IBM</creator> |
| <description> |
| Using lookupPrefix on a new Document node with a namespaceURI and prefix |
| and check if the value returned is the same prefix. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="qname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <plus var="qname" op1='"dom3:"' op2="rootName"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="qname" doctype="nullDocType"/> |
| <lookupPrefix var="prefix" obj="newDoc" namespaceURI="rootNS"/> |
| <assertEquals actual="prefix" expected='"dom3"' id="nodelookupprefix02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix03"> |
| <metadata> |
| <title>nodelookupprefix03</title> |
| <creator>IBM</creator> |
| <description> |
| Using lookupPrefix on this DocumentType node check if the value returned is Null . |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="nullNSURI" type="DOMString" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <lookupPrefix var="prefix" obj="docType" namespaceURI="nullNSURI"/> |
| <assertNull actual="prefix" id="nodelookupprefix03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix04.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix04"> |
| <metadata> |
| <title>nodelookupprefix04</title> |
| <creator>IBM</creator> |
| <description> |
| Using lookupPrefix on an Entity and Notation node and check if the value returned is Null . |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entity" type="Entity"/> |
| <var name="notation" type="Notation"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <notations var="notationsMap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitiesMap" name='"alpha"'/> |
| <getNamedItem var="notation" obj="notationsMap" name='"notation1"'/> |
| <lookupPrefix var="prefix" obj="entity" namespaceURI='""' interface="Node"/> |
| <assertNull actual="prefix" id="nodelookupprefixEntity04"/> |
| <lookupPrefix var="prefix" obj="notation" namespaceURI='""' interface="Node"/> |
| <assertNull actual="prefix" id="nodelookupprefixNotation04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix05.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix05"> |
| <metadata> |
| <title>nodelookupprefix05</title> |
| <creator>IBM</creator> |
| <description> |
| Using lookupPrefix on the DocumentElement node of a new document with a |
| namespaceURI and prefix and check if the prefix value returned is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="qname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <plus var="qname" op1='"dom3:"' op2="rootName"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="qname" doctype="nullDocType"/> |
| <documentElement var="elem" obj="newDoc"/> |
| <lookupPrefix var="prefix" obj="elem" namespaceURI="rootNS"/> |
| <assertEquals actual="prefix" expected='"dom3"' id="nodelookupprefix05" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix06.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix06"> |
| <metadata> |
| <title>nodelookupprefix06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on an Element node with no prefix, which has a namespace |
| attribute declaration with a namespace prefix and check if the value of the prefix |
| returned by using its namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="2" interface="NodeList"/> |
| <lookupPrefix var="prefix" obj="elem" namespaceURI='"http://www.netzero.com"'/> |
| <assertEquals actual="prefix" expected='"dmstc"' id="nodelookupprefix06" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix07.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix07"> |
| <metadata> |
| <title>nodelookupprefix07</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on an Element node with no prefix, which has a namespace |
| attribute declaration with a namespace prefix in its parent Element node and check if the value of the prefix |
| returned by using its namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="2" interface="NodeList"/> |
| <lookupPrefix var="prefix" obj="elem" namespaceURI='"http://www.netzero.com"'/> |
| <assertEquals actual="prefix" expected='"dmstc"' id="nodelookupprefix07" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix08.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix08"> |
| <metadata> |
| <title>nodelookupprefix08</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on an Element node with no prefix, which has 2 namespace |
| attribute declarations with and without namespace prefixes and check if the value of the prefix |
| returned by using each namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="prefixEmpty" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <lookupPrefix var="prefix" obj="elem" namespaceURI='"http://www.usa.com"'/> |
| <assertEquals actual="prefix" expected='"dmstc"' id="nodelookupprefix08" ignoreCase="false"/> |
| <lookupPrefix var="prefixEmpty" obj="elem" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertNull actual="prefixEmpty" id="nodelookupnamespaceprefixEmpty08"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix09.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix09"> |
| <metadata> |
| <title>nodelookupprefix09</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on an Element node with no prefix, whose parent has no prefix and |
| 2 namespace attribute declarations with and without namespace prefixes and check if the value of |
| the prefix returned by using each namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="prefixEmpty" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <lookupPrefix var="prefix" obj="elem" namespaceURI='"http://www.usa.com"'/> |
| <assertEquals actual="prefix" expected='"dmstc"' id="nodelookupprefix09" ignoreCase="false"/> |
| <lookupPrefix var="prefixEmpty" obj="elem" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertNull actual="prefixEmpty" id="nodelookupprefixEmpty09"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix10.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix10"> |
| <metadata> |
| <title>nodelookupprefix10</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on a new Child of a new Element node with a namespace URI |
| and prefix and using the parents namespace URI as an argument, verify if the prefix |
| returned is a valid prefix of the parent. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="Element"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createElement var="child" obj="doc" tagName='"br"'/> |
| <appendChild obj="parent" var="appendedChild" newChild="child"/> |
| <lookupPrefix var="prefix" obj="child" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertEquals actual="prefix" expected='"dom3"' id="nodelookupprefix10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix11.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix11"> |
| <metadata> |
| <title>nodelookupprefix11</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on an imported new Element node with a namespace URI |
| and prefix in a new Document and using the parents namespace URI as an argument, verify if the prefix |
| returned is a valid prefix of the parent. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="importedNode" type="Element"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="qname" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <plus var="qname" op1='"dom3doc:"' op2="rootName"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="qname" doctype="nullDocType"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:br"'/> |
| <importNode var="importedNode" obj="newDoc" importedNode="elem" deep="true"/> |
| <lookupPrefix var="prefix" obj="importedNode" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertEquals actual="prefix" expected='"dom3"' id="nodelookupprefix11" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix12.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix12"> |
| <metadata> |
| <title>nodelookupprefix12</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on an renamed new Element node with a namespace URI |
| and prefix in a new Document and using the parents namespace URI as an argument, verify if the prefix |
| returned is a valid prefix of the parent. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="elem" type="Element"/> |
| <var name="renamedNode" type="Element"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <renameNode var="renamedNode" obj="doc" n="elem" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"ren:br"'/> |
| <lookupPrefix var="prefix" obj="renamedNode" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertEquals actual="prefix" expected='"ren"' id="nodelookupprefix12" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix13.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix13"> |
| <metadata> |
| <title>nodelookupprefix13</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on a Element's new Text node, which has a namespace attribute declaration |
| with a namespace prefix in its parent Element node and check if the value of the prefix |
| returned by using its namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="bodyList" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createTextNode var="txt" obj="doc" data='"Text"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="txt"/> |
| <appendChild obj="bodyElem" var="appendedChild" newChild="elem"/> |
| <lookupPrefix var="prefix" obj="txt" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertEquals actual="prefix" expected='"dom3"' id="nodelookupprefix13" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix14.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix14"> |
| <metadata> |
| <title>nodelookupprefix14</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on a Element's new CDATA node, which has a namespace attribute declaration |
| with a namespace prefix in its parent Element node and check if the value of the prefix |
| returned by using its namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="bodyList" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createCDATASection var="cdata" obj="doc" data='"Text"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="cdata"/> |
| <appendChild obj="bodyElem" var="appendedChild" newChild="elem"/> |
| <lookupPrefix var="prefix" obj="cdata" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertEquals actual="prefix" expected='"dom3"' id="nodelookupprefix14" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix15.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix15"> |
| <metadata> |
| <title>nodelookupprefix15</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on a Element's new Comment node, which has a namespace attribute declaration |
| with a namespace prefix in its parent Element node and check if the value of the prefix |
| returned by using its namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="comment" type="Comment"/> |
| <var name="clonedComment" type="Comment"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="bodyList" type="NodeList"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createComment var="comment" obj="doc" data='"Text"'/> |
| <cloneNode var="clonedComment" obj="comment" deep="true"/> |
| <appendChild obj="elem" var="appendedChild" newChild="clonedComment"/> |
| <appendChild obj="bodyElem" var="appendedChild" newChild="elem"/> |
| <lookupPrefix var="prefix" obj="clonedComment" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertEquals actual="prefix" expected='"dom3"' id="nodelookupprefix15" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix16.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix16"> |
| <metadata> |
| <title>nodelookupprefix16</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on a new Attribute node with with a namespace URI |
| and prefix and verify if the prefix returned is null. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="prefix" type="DOMString"/> |
| <var name="attNode" type="Attr"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <setAttributeNodeNS obj="elem" var="attNode" newAttr="attr"/> |
| <lookupPrefix var="prefix" obj="attr" namespaceURI='"http://www.w3.org/XML/1998/namespace"'/> |
| <assertNull actual="prefix" id="nodelookupprefix16"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix17.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix17"> |
| <metadata> |
| <title>nodelookupprefix17</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on the title attribute node of the acronym node with |
| a namespaceURI and a node prefix and check if the value of the prefix returned by |
| using its namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="2" interface="NodeList"/> |
| <attributes var="attributesMap" obj="elem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xsi:noNamespaceSchemaLocation"'/> |
| <lookupPrefix var="prefix" obj="attr" namespaceURI='"http://www.netzero.com"'/> |
| <assertEquals actual="prefix" expected='"dmstc"' id="nodelookupprefix17" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix18.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix18"> |
| <metadata> |
| <title>nodelookupprefix18</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on the default attribute node of the p node with |
| a namespaceURI and a node prefix and check if the value of the prefix returned by |
| using its namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <attributes var="attributesMap" obj="elem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"dir"'/> |
| <lookupPrefix var="prefix" obj="attr" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertNull actual="prefix" id="xhtmlPrefixIsNull"/> |
| <lookupPrefix var="prefix" obj="attr" namespaceURI='"http://www.altavista.com"'/> |
| <assertEquals actual="prefix" expected='"nm"' id="nodelookupprefixB18" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix19.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix19"> |
| <metadata> |
| <title>nodelookupprefix19</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on the an attribute node without a namespace prefix of |
| an Element node that has a namespaceURI and prefix, and check if the value of the prefix |
| returned by using the Elements namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="barfoo_nodefaultns" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"html:p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <attributes var="attributesMap" obj="elem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"class"'/> |
| <lookupPrefix var="prefix" obj="attr" namespaceURI='"http://www.w3.org/1999/xhtml"'/> |
| <assertEquals actual="prefix" expected='"html"' id="nodelookupprefix19" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodelookupprefix20.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodelookupprefix20"> |
| <metadata> |
| <title>nodelookupprefix20</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke lookupPrefix on the an attribute node without a namespace prefix of |
| an Element node that has a namespaceURI and prefix, and check if the value of the prefix |
| returned by using the Elements namespaceURI as a parameter is valid. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-lookupNamespacePrefix"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="attributesMap" type="NamedNodeMap"/> |
| <var name="attr" type="Attr"/> |
| <var name="prefix" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <attributes var="attributesMap" obj="elem"/> |
| <getNamedItem var="attr" obj="attributesMap" name='"xmlns:nm"'/> |
| <lookupPrefix var="prefix" obj="attr" namespaceURI='"http://www.altavista.com"'/> |
| <assertEquals actual="prefix" expected='"nm"' id="nodelookupprefix20" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild01"> |
| <metadata> |
| <title>noderemovechild01</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on this Document node attempt to remove this Document node and |
| verify if a NOT_FOUND_ERR error is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="removed" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <assertDOMException id="NOT_FOUND_ERR_noderemovechild01"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="doc" var="removed" oldChild="doc" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild02.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild02"> |
| <metadata> |
| <title>noderemovechild02</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on this Document node attempt to remove a new Document node and |
| vice versa and verify if a NOT_FOUND_ERR error is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="removed" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR_1"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="doc" var="removed" oldChild="newDoc" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NOT_FOUND_ERR_2"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="newDoc" var="removed" oldChild="doc" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild03.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild03"> |
| <metadata> |
| <title>noderemovechild03</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on this DocumentElement node attempt to remove this Document node and |
| verify if the DocumentElement is null. Now try the reverse and a NOT_FOUND_ERR should be |
| thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="removedChild" type="Element"/> |
| <var name="removed" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <removeChild obj="doc" var="removed" oldChild="docElem" /> |
| <documentElement var="removedChild" obj="doc"/> |
| <assertNull actual="removedChild" id="noderemovechild03"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="docElem" var="removed" oldChild="doc" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild04.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild04"> |
| <metadata> |
| <title>noderemovechild04</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on this Document node attempt to remove DocumentType node and |
| verify if the DocumentType node is null. Now try the reverse and a NOT_FOUND_ERR should be |
| thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="removedDocType" type="DocumentType"/> |
| <var name="removed" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <removeChild obj="doc" var="removed" oldChild="docType" /> |
| <doctype var="removedDocType" obj="doc"/> |
| <assertNull actual="removedDocType" id="noderemovechild04"/> |
| <assertDOMException id="NOT_FOUND_ERR_noderemovechild04"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="docType" var="removed" oldChild="doc" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild05.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild05"> |
| <metadata> |
| <title>noderemovechild05</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on this Document node attempt to remove a new DocumentType node and |
| verify if the DocumentType node is null. Attempting to remove the DocumentType |
| a second type should result in a NOT_FOUND_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=417"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="removedDocType" type="DocumentType"/> |
| <var name="nullPubId" type="DOMString" isNull="true"/> |
| <var name="nullSysId" type="DOMString" isNull="true"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="removedChild" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <!-- An implemention may not support removing doctype --> |
| <try> |
| <removeChild obj="doc" var="removedChild" oldChild="docType" /> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <assertNotNull actual="removedChild" id="removedChildNotNull"/> |
| <doctype var="removedDocType" obj="doc"/> |
| <assertNull actual="removedDocType" id="noderemovechild05"/> |
| <assertDOMException id="NOT_FOUND_ERR_noderemovechild05"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="docType" var="removedChild" oldChild="doc" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild07.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild07"> |
| <metadata> |
| <title>noderemovechild07</title> |
| <creator>IBM</creator> |
| <description> |
| Attempts to remove a notation from a Document node. Since notations are children of |
| DocumentType, not Document the operation should fail with a NOT_FOUND_ERR. Attempting |
| to remove Document from a Notation should also fail either with a NOT_FOUND_ERR |
| or a NO_MODIFICATION_ALLOWED_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=418"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="removedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notations" obj="docType"/> |
| <getNamedItem var="notation" obj="notations" name='"notation1"'/> |
| <assertDOMException id="NOT_FOUND_ERR_noderemovechild07_1"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="doc" var="removedChild" oldChild="notation" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| <try> |
| <removeChild obj="notation" var="removedChild" oldChild="doc" /> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"/> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild08.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild08"> |
| <metadata> |
| <title>noderemovechild08</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on this Document node attempt to remove a new Comment node and |
| verify the data of the removed comment node.. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="comment" type="Comment"/> |
| <var name="removedCmt" type="Comment"/> |
| <var name="data" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createComment var="comment" obj="doc" data='"Comment"'/> |
| <appendChild obj="doc" var="appendedChild" newChild="comment"/> |
| <removeChild var="removedCmt" obj="doc" oldChild="comment" /> |
| <data var="data" obj="removedCmt" interface="CharacterData"/> |
| <assertEquals actual="data" expected='"Comment"' id="noderemovechild08" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild09.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild09"> |
| <metadata> |
| <title>noderemovechild09</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on this Document node attempt to remove a new ProcessingInstruction node and |
| verify the target of the removed ProcessingInstruction node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="removedPi" type="ProcessingInstruction"/> |
| <var name="target" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createProcessingInstruction var="pi" obj="doc" data='"PID"' target='"PIT"'/> |
| <appendChild obj="doc" var="appendedChild" newChild="pi"/> |
| <removeChild var="removedPi" obj="doc" oldChild="pi" /> |
| <target var="target" obj="removedPi" interface="ProcessingInstruction"/> |
| <assertEquals actual="target" expected='"PIT"' id="noderemovechild09" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild10.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild10"> |
| <metadata> |
| <title>noderemovechild10</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a new DocumentFragment node attempt to remove a new Element node and |
| verify the name of the removed Element node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="elem" type="Element"/> |
| <var name="removedElem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="removedChild" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:br"'/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="elem"/> |
| <removeChild var="removedElem" obj="docFrag" oldChild="elem" /> |
| <nodeName var="elemName" obj="removedElem"/> |
| <assertEquals actual="elemName" expected='"dom3:br"' id="noderemovechild10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild11.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild11"> |
| <metadata> |
| <title>noderemovechild11</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a new DocumentFragment node attempt to remove a new Text node and |
| verify the name of the removed Element node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="txt" type="Text"/> |
| <var name="removedTxt" type="Text"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="removedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createTextNode var="txt" obj="doc" data='"TEXT"'/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="txt"/> |
| <removeChild obj="docFrag" var="removedChild" oldChild="txt" /> |
| <firstChild var="removedTxt" obj="docFrag" interface="Node"/> |
| <assertNull actual="removedTxt" id="noderemovechild11"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild12.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild12"> |
| <metadata> |
| <title>noderemovechild12</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeChild removes the child node indicated by oldChild from the list |
| of children, and returns it. |
| Using removeChild on a new DocumentFragment node attempt to remove a new EntityReference node. |
| Also attempt to remove the document fragment node from the EntityReference. Verify that a |
| NO_MODIFICATION_ALLOWED_ERR (EntityReference node is read-only) or a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="eRef" type="EntityReference"/> |
| <var name="removedERef" type="EntityReference"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="removedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createEntityReference var="eRef" obj="doc" name='"ent1"'/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="eRef"/> |
| <removeChild obj="docFrag" var="removedChild" oldChild="eRef" /> |
| <firstChild var="removedERef" obj="docFrag" interface="Node"/> |
| <assertNull actual="removedERef" id="noderemovechild12"/> |
| <try> |
| <removeChild obj="eRef" var="removedChild" oldChild="docFrag" /> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"/> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild13.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild13"> |
| <metadata> |
| <title>noderemovechild13</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a new EntityReference node attempt to remove the first child |
| of this node and verify if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="txt" type="Text"/> |
| <var name="eRef" type="EntityReference"/> |
| <var name="removed" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEntityReference var="eRef" obj="doc" name='"alpha"'/> |
| <firstChild obj="eRef" var="txt" interface="Node"/> |
| <assertNotNull actual="txt" id="txtNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild obj="eRef" var="removed" oldChild="txt" /> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild14.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild14"> |
| <metadata> |
| <title>noderemovechild14</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a new EntityReference node attempt to remove its last ProcessingInstruction |
| child node and verify if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="removed" type="Node"/> |
| <var name="eRef" type="EntityReference"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="entName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEntityReference var="eRef" obj="doc" name='"ent4"'/> |
| <lastChild obj="eRef" var="pi" interface="Node"/> |
| <assertNotNull actual="pi" id="piNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild obj="eRef" var="removed" oldChild="pi" /> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild15.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild15"> |
| <metadata> |
| <title>noderemovechild15</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a new EntityReference node attempt to remove an Element child |
| and verify if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="eRef" type="EntityReference"/> |
| <var name="elem" type="Element"/> |
| <var name="entName" type="DOMString"/> |
| <var name="removed" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEntityReference var="eRef" obj="doc" name='"ent4"'/> |
| <firstChild obj="eRef" var="elem" interface="Node"/> |
| <assertNotNull actual="elem" id="elemNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild obj="eRef" var="removed" oldChild="elem" /> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild16.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild16"> |
| <metadata> |
| <title>noderemovechild16</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on the first 'p' Element node attempt to remove its 'em' |
| Element child and verify the name of the returned node that was removed. Now attempt |
| the reverse and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <implementationAttribute name="ignoringElementContentWhitespace" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="parentList" type="NodeList"/> |
| <var name="childList" type="NodeList"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="Element"/> |
| <var name="removed" type="Element"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="parentList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="child" obj="parentList" index="0" interface="NodeList"/> |
| <parentNode var="parent" obj="child" interface="Node"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeName obj="removed" var="removedName"/> |
| <assertEquals actual="removedName" expected='"em"' id="noderemovechild16" ignoreCase="false"/> |
| <assertDOMException id="NOT_FOUND_ERR_noderemovechild16"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="child" var="removedNode" oldChild="parent" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild17.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild17"> |
| <metadata> |
| <title>noderemovechild17</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on the first 'p' Element node attempt to remove a Text |
| node child and verify the contents of the returned node that was removed. Now attempt |
| the reverse and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parentList" type="NodeList"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="Text"/> |
| <var name="removed" type="Text"/> |
| <var name="removedValue" type="DOMString"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="parentList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="parent" obj="parentList" index="0" interface="NodeList"/> |
| <firstChild var="child" obj="parent" interface="Node"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeValue obj="removed" var="removedValue"/> |
| <assertEquals actual="removedValue" expected='"EMP0001"' id="noderemovechild17" ignoreCase="false"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="child" var="removedNode" oldChild="parent" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild18.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild18"> |
| <metadata> |
| <title>noderemovechild18</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on the first 'p' Element node attempt to remove a CDATASection |
| node child and verify the contents of the returned node that was removed. Now attempt |
| the reverse and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parentList" type="NodeList"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="CDATASection"/> |
| <var name="removed" type="CDATASection"/> |
| <var name="removedValue" type="DOMString"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="parentList" obj="doc" tagname='"strong"' interface="Document" /> |
| <item var="parent" obj="parentList" index="1" interface="NodeList"/> |
| <lastChild var="child" obj="parent" interface="Node"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeValue obj="removed" var="removedValue"/> |
| <assertEquals actual="removedValue" expected='"This is an adjacent CDATASection with a reference to a tab &tab;"' id="noderemovechild18" ignoreCase="false"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="child" var="removedNode" oldChild="parent" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild19.xml |
|---|
| 0,0 → 1,76 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild19"> |
| <metadata> |
| <title>noderemovechild19</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on the first 'p' Element node attempt to remove a EntityReference |
| node child and verify the nodeName of the returned node that was removed. Attempt |
| to remove a non-child from an entity reference and expect either a NOT_FOUND_ERR or |
| a NO_MODIFICATION_ALLOWED_ERR. Renove a child from an entity reference and expect |
| a NO_MODIFICATION_ALLOWED_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="parentList" type="NodeList"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="EntityReference"/> |
| <var name="removed" type="EntityReference"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="removedNode" type="Node"/> |
| <var name="entRefChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="parentList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="parent" obj="parentList" index="1" interface="NodeList"/> |
| <firstChild var="child" obj="parent" interface="Node"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeName obj="removed" var="removedName"/> |
| <assertEquals actual="removedName" expected='"beta"' id="noderemovechild19" ignoreCase="false"/> |
| <!-- |
| Remove a non-member of the entity reference, |
| expect either a NO_MODIFICATION_ALLOWED_ERR or a NOT_FOUND_ERR |
| --> |
| <try> |
| <removeChild obj="child" var="removedNode" oldChild="parent" /> |
| <fail id="throw_DOMException"/> |
| <catch> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| <DOMException code="NOT_FOUND_ERR"/> |
| </catch> |
| </try> |
| <!-- |
| Remove a child of the entity reference |
| Expect a NO_MODIFICATION_ALLOWED_ERR exception |
| --> |
| <firstChild var="entRefChild" obj="child" interface="Node"/> |
| <if> |
| <!-- entity may not be resolved if validating is false --> |
| <notNull obj="entRefChild"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild obj="child" var="removedNode" oldChild="entRefChild"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild20.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild20"> |
| <metadata> |
| <title>noderemovechild20</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on the first 'p' Element node attempt to remove a new |
| Element child and verify the name of the returned node that was removed. Now attempt |
| to do the same on a cloned child and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parentList" type="NodeList"/> |
| <var name="childList" type="NodeList"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="Element"/> |
| <var name="clonedChild" type="Element"/> |
| <var name="removed" type="Element"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="parentList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="parent" obj="parentList" index="0" interface="NodeList"/> |
| <createElementNS var="child" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:br"'/> |
| <appendChild obj="parent" var="appendedChild" newChild="child"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeName obj="removed" var="removedName"/> |
| <assertEquals actual="removedName" expected='"dom3:br"' id="noderemovechild20" ignoreCase="false"/> |
| <cloneNode var="clonedChild" obj="child" deep="true"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="parent" var="removedNode" oldChild="clonedChild" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild21.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild21"> |
| <metadata> |
| <title>noderemovechild21</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a new Element node attempt to remove a new Element child |
| and verify the name of the returned node that was removed. Now append the parent |
| to the documentElement and attempt to remove the child using removeChild on the |
| documentElement and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="Element"/> |
| <var name="removed" type="Element"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="removedNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createElementNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createElementNS var="child" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:br"'/> |
| <appendChild obj="parent" var="appendedChild" newChild="child"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="parent"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeName obj="removed" var="removedName"/> |
| <assertEquals actual="removedName" expected='"dom3:br"' id="noderemovechild21" ignoreCase="false"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="docElem" var="removedNode" oldChild="child" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild22.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild22"> |
| <metadata> |
| <title>noderemovechild22</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a new Element node attempt to remove a new Comment child |
| and verify the name of the rturned node that was removed. Now to remove the child |
| using removeChild on the parent and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="Comment"/> |
| <var name="removed" type="Comment"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="removedNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createComment var="child" obj="doc" data='"DATA"' /> |
| <appendChild obj="parent" var="appendedChild" newChild="child"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeValue obj="removed" var="removedName"/> |
| <assertEquals actual="removedName" expected='"DATA"' id="noderemovechild22" ignoreCase="false"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="parent" var="removedNode" oldChild="child" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild23.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild23"> |
| <metadata> |
| <title>noderemovechild23</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a new Element node attempt to remove a new ProcessingInstruction child |
| and verify the name of the returned node that was removed. Now to remove the child |
| using removeChild on the parent and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parent" type="Element"/> |
| <var name="child" type="ProcessingInstruction"/> |
| <var name="removed" type="ProcessingInstruction"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="removedNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createProcessingInstruction var="child" obj="doc" data='"DATA"' target='"TARGET"'/> |
| <appendChild obj="parent" var="appendedChild" newChild="child"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <target obj="removed" var="removedName" interface="ProcessingInstruction"/> |
| <assertEquals actual="removedName" expected='"TARGET"' id="noderemovechild23" ignoreCase="false"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="parent" var="removedNode" oldChild="child" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild24.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild24"> |
| <metadata> |
| <title>noderemovechild24</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on an Entity node attempt to remove a Text child |
| and verify if a NO_MODIFICATION_ALLOWED_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="alphaEntity" type="Entity"/> |
| <var name="alphaText" type="Text"/> |
| <var name="removed" type="Text"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="alphaEntity" obj="entitiesMap" name='"alpha"' interface="NamedNodeMap"/> |
| <assertNotNull actual="alphaEntity" id="alphaEntityNotNull"/> |
| <firstChild var="alphaText" obj="alphaEntity" interface="Node"/> |
| <assertNotNull actual="alphaText" id="alphaTextNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild var="removed" obj="alphaEntity" oldChild="alphaText" /> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild25.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild25"> |
| <metadata> |
| <title>noderemovechild25</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on an Entity node attempt to remove an Element child |
| and verify if a NO_MODIFICATION_ALLOWED_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="ent4" type="Entity"/> |
| <var name="span" type="Element"/> |
| <var name="removed" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="ent4" interface="NamedNodeMap" obj="entitiesMap" name='"ent4"'/> |
| <assertNotNull actual="ent4" id="ent4NotNull"/> |
| <firstChild var="span" obj="ent4" interface="Node"/> |
| <assertNotNull actual="span" id="spanNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild obj="ent4" var="removed" oldChild="span" /> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild26.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild26"> |
| <metadata> |
| <title>noderemovechild26</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on an Entity node attempt to remove a ProcessingInstruction child |
| and verify if a NO_MODIFICATION_ALLOWED_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="ent4" type="Entity"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="removed" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <getNamedItem var="ent4" interface="NamedNodeMap" obj="entitiesMap" name='"ent4"'/> |
| <assertNotNull actual="ent4" id="ent4NotNull"/> |
| <lastChild var="pi" obj="ent4" interface="Node"/> |
| <assertNotNull actual="pi" id="piNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild obj="ent4" var="removed" oldChild="pi" /> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild27.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild27"> |
| <metadata> |
| <title>noderemovechild27</title> |
| <creator>IBM</creator> |
| <description> |
| The method removeChild removes the child node indicated by oldChild from the list |
| of children, and returns it. |
| Using removeChild on a Notation node attempt to remove an Entity node |
| and verify if a NO_MODIFICATION_ALLOWED_ERR or a NOT_FOUND_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="child" type="Entity"/> |
| <var name="parent" type="Notation"/> |
| <var name="removed" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitiesMap" obj="docType"/> |
| <notations var="notationsMap" obj="docType"/> |
| <getNamedItem var="child" interface="NamedNodeMap" obj="entitiesMap" name='"ent1"'/> |
| <getNamedItem var="parent" interface="NamedNodeMap" obj="notationsMap" name='"notation1"'/> |
| <try> |
| <removeChild obj="parent" var="removed" oldChild="child" /> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"/> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild28.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild28"> |
| <metadata> |
| <title>noderemovechild28</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on an Attribute node attempt to remove its Text child node and |
| and verify the name of the returned node that was removed. Now attempt the reverse |
| and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parentList" type="NodeList"/> |
| <var name="attrsMap" type="NamedNodeMap"/> |
| <var name="parent" type="Attr"/> |
| <var name="child" type="Text"/> |
| <var name="elem" type="Element"/> |
| <var name="removed" type="Text"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="parentList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="parentList" index="0" interface="NodeList"/> |
| <attributes var="attrsMap" obj="elem"/> |
| <getNamedItem var="parent" obj="attrsMap" name='"xsi:noNamespaceSchemaLocation"'/> |
| <firstChild var="child" obj="parent" interface="Node"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeValue obj="removed" var="removedName"/> |
| <assertEquals actual="removedName" expected='"Yes"' id="noderemovechild28" ignoreCase="false"/> |
| <assertDOMException id="NOT_FOUND_ERR_noderemovechild28"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="child" var="removedNode" oldChild="parent" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild29.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild29"> |
| <metadata> |
| <title>noderemovechild29</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a namespace Attribute node attempt to remove its Text child node and |
| and verify the name of the returned node that was removed. Now attempt the reverse |
| and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parentList" type="NodeList"/> |
| <var name="attrsMap" type="NamedNodeMap"/> |
| <var name="parent" type="Attr"/> |
| <var name="child" type="Text"/> |
| <var name="elem" type="Element"/> |
| <var name="removed" type="Text"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="removedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="parentList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="parentList" index="0" interface="NodeList"/> |
| <attributes var="attrsMap" obj="elem"/> |
| <getNamedItem var="parent" obj="attrsMap" name='"xmlns:dmstc"'/> |
| <firstChild var="child" obj="parent" interface="Node"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeValue obj="removed" var="removedName"/> |
| <assertEquals actual="removedName" expected='"http://www.usa.com"' id="noderemovechild29" ignoreCase="false"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="child" var="removedNode" oldChild="parent" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild30.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild30"> |
| <metadata> |
| <title>noderemovechild30</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a default Attribute node attempt to remove its Text child node and |
| and verify the name of the returned node that was removed. Now attempt the reverse |
| and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parentList" type="NodeList"/> |
| <var name="attrsMap" type="NamedNodeMap"/> |
| <var name="parent" type="Attr"/> |
| <var name="child" type="Text"/> |
| <var name="elem" type="Element"/> |
| <var name="removed" type="Text"/> |
| <var name="removedNode" type="Node"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="parentList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="parentList" index="3" interface="NodeList"/> |
| <attributes var="attrsMap" obj="elem"/> |
| <getNamedItem var="parent" obj="attrsMap" name='"dir"'/> |
| <firstChild var="child" obj="parent" interface="Node"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeValue obj="removed" var="removedName"/> |
| <assertEquals actual="removedName" expected='"rtl"' id="noderemovechild30" ignoreCase="false"/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <removeChild obj="child" var="removedNode" oldChild="parent" /> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/noderemovechild31.xml |
|---|
| 0,0 → 1,84 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noderemovechild31"> |
| <metadata> |
| <title>noderemovechild31</title> |
| <creator>IBM</creator> |
| <description> |
| Using removeChild on a default Attribute node attempt to remove its EntityReference child node and |
| and verify the name of the returned node that was removed. Now attempt the reverse |
| and verify if a NO_MODIFICATION_ALLOWED_ERR or NOT_FOUND_ERR is thrown. |
| Then remove an child of the entity reference and expect a NO_MODIFICATION_ALLOWED_ERR. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-1734834066"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="parentList" type="NodeList"/> |
| <var name="attrsMap" type="NamedNodeMap"/> |
| <var name="parent" type="Attr"/> |
| <var name="child" type="EntityReference"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="elem" type="Element"/> |
| <var name="removed" type="EntityReference"/> |
| <var name="removedNode" type="Node"/> |
| <var name="removedName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="entRefChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="parentList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="parentList" index="3" interface="NodeList"/> |
| <attributes var="attrsMap" obj="elem"/> |
| <getNamedItem var="parent" obj="attrsMap" name='"class"'/> |
| <createEntityReference var="entRef" obj="doc" name='"delta"'/> |
| <appendChild obj="parent" var="appendedChild" newChild="entRef"/> |
| <lastChild var="child" obj="parent" interface="Node"/> |
| <removeChild var="removed" obj="parent" oldChild="child" /> |
| <nodeName obj="removed" var="removedName"/> |
| <assertEquals actual="removedName" expected='"delta"' id="noderemovechild31" ignoreCase="false"/> |
| <!-- |
| Remove a non-child from an entity reference |
| Should throw either a NO_MODIFICATION_ALLOWED_ERR or a NOT_FOUND_ERR |
| --> |
| <try> |
| <removeChild obj="child" var="removedNode" oldChild="parent" /> |
| <fail id="throw_DOMException"/> |
| <catch> |
| <DOMException code="NO_MODIFICATION_ALLOWED_ERR"/> |
| <DOMException code="NOT_FOUND_ERR"/> |
| </catch> |
| </try> |
| <!-- |
| Remove a child of the entity reference |
| Expect a NO_MODIFICATION_ALLOWED_ERR exception |
| --> |
| <firstChild var="entRefChild" obj="child" interface="Node"/> |
| <if> |
| <!-- entity may not be resolved if validating is false --> |
| <notNull obj="entRefChild"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <removeChild obj="child" var="removedNode" oldChild="entRefChild"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild01.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild01"> |
| <metadata> |
| <title>nodereplacechild01</title> |
| <creator>IBM</creator> |
| <description> |
| The method replaceChild replaces the child node oldChild with newChild in the list of |
| children, and returns the oldChild node. |
| Using replaceChild on this Document node attempt to replace this Document node with itself |
| and verify if a HIERARCHY_REQUEST_ERR error or a NOT_FOUND_ERR (since oldChild |
| is not a child of this node) is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <try> |
| <replaceChild obj="doc" var="replaced" oldChild="doc" newChild="doc"/> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"/> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild02.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild02"> |
| <metadata> |
| <title>nodereplacechild02</title> |
| <creator>IBM</creator> |
| <description> |
| The method replaceChild replaces the child node oldChild with newChild in the list of |
| children, and returns the oldChild node. |
| Using replaceChild on this Document node attempt to replace this DocumentType node with |
| its DocumentType (replacing node with itself -- implementation dependent) |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc"/> |
| <replaceChild obj="doc" var="replaced" oldChild="docType" newChild="docType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild03.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild03"> |
| <metadata> |
| <title>nodereplacechild03</title> |
| <creator>IBM</creator> |
| <description> |
| The method replaceChild replaces the child node oldChild with newChild in the list of |
| children, and returns the oldChild node. |
| Using replaceChild on this Document node attempt to replace this Document node with |
| a new DocumentNode and verify if a HIERARCHY_REQUEST_ERR, WRONG_DOCUMENT_ERR |
| or NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM"' qualifiedName='"dom3:doc"' doctype="nullDocType"/> |
| <try> |
| <replaceChild obj="doc" var="replaced" oldChild="doc" newChild="newDoc"/> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"/> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="WRONG_DOCUMENT_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild04.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild04"> |
| <metadata> |
| <title>nodereplacechild04</title> |
| <creator>IBM</creator> |
| <description> |
| The method replaceChild replaces the child node oldChild with newChild in the list of |
| children, and returns the oldChild node. |
| Using replaceChild on this Document node attempt to replace this DocumentElement node with |
| this Document Node and verify if a HIERARCHY_REQUEST_ERR or a NOT_FOUND_ERR error is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <documentElement var="docElem" obj="doc"/> |
| <try> |
| <replaceChild obj="doc" var="replaced" oldChild="docElem" newChild="doc"/> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"/> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild06.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild06"> |
| <metadata> |
| <title>nodereplacechild06</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on this Document node attempt to replace this DocumentElement node |
| with one of its child elements and verify if the name of the replaced documentElement Node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="replaced" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="childList" type="NodeList"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="replacedNode" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="childList" index="0" interface="NodeList"/> |
| <try> |
| <replaceChild obj="doc" var="replacedNode" oldChild="docElem" newChild="elem"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <documentElement var="replaced" obj="doc"/> |
| <nodeName obj="replaced" var="nodeName"/> |
| <assertEquals actual="nodeName" expected='"p"' id="nodereplacechild06" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild07.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild07"> |
| <metadata> |
| <title>nodereplacechild07</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on this Document node attempt to replace this DocumentElement node |
| with a new element and verify if the name of the replaced documentElement Node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="replaced" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="replacedNode" type="Node"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='rootNS' qualifiedName='rootName'/> |
| <try> |
| <replaceChild obj="doc" var="replacedNode" oldChild="docElem" newChild="elem"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <documentElement var="replaced" obj="doc"/> |
| <nodeName obj="replaced" var="nodeName"/> |
| <assertEquals actual="nodeName" expected='rootName' id="nodereplacechild07" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild08.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild08"> |
| <metadata> |
| <title>nodereplacechild08</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on this Document node attempt to replace this DocumentElement node |
| with a new element that was created in another document and verify if a |
| WRONG_DOCUMENT_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="replaced" type="Node"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc2" obj="domImpl" namespaceURI="rootNS" qualifiedName="rootName" doctype="nullDocType"/> |
| <createElementNS var="elem" obj="doc2" namespaceURI='rootNS' qualifiedName='rootName'/> |
| <try> |
| <replaceChild obj="doc" var="replaced" oldChild="docElem" newChild="elem"/> |
| <fail id="throw_WRONG_DOCUMENT_OR_NOT_SUPPORTED"/> |
| <catch> |
| <DOMException code="WRONG_DOCUMENT_ERR"/> |
| <DOMException code="NOT_SUPPORTED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild10.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild10"> |
| <metadata> |
| <title>nodereplacechild10</title> |
| <creator>IBM</creator> |
| <description> |
| The method replaceChild replaces the child node oldChild with newChild in the list of |
| children, and returns the oldChild node. |
| Using replaceChild on this Document node attempt to replace an Entity node with |
| a notation node of retieved from the DTD of another document and verify if a |
| NOT_FOUND_ERR or WRONG_DOCUMENT_ERR or HIERARCHY_REQUEST err is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="ent" type="Entity"/> |
| <var name="doc1" type="Document"/> |
| <var name="docType1" type="DocumentType"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc" /> |
| <entities var="entitiesMap" obj="docType" /> |
| <getNamedItem var="ent" obj="entitiesMap" name='"alpha"'/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType1" obj="doc1" /> |
| <notations var="notationsMap" obj="docType1" /> |
| <getNamedItem var="notation" obj="notationsMap" name='"notation1"'/> |
| <try> |
| <replaceChild obj="doc" var="replaced" oldChild="ent" newChild="notation"/> |
| <catch> |
| <DOMException code="NOT_FOUND_ERR"/> |
| <DOMException code="WRONG_DOCUMENT_ERR"/> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild12.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild12"> |
| <metadata> |
| <title>nodereplacechild12</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on this Document node, attempt to replace a new ProcessingInstruction |
| node with new Comment node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=416"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="replaced" type="Node"/> |
| <var name="comment" type="Comment"/> |
| <var name="lastChild" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="replacedNode" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <createComment var="comment" obj="doc" data='"dom3:doc"'/> |
| <createProcessingInstruction var="pi" obj="doc" target='"PITarget"' data='"PIData"'/> |
| <appendChild obj="doc" var="appendedChild" newChild="comment"/> |
| <appendChild obj="doc" var="appendedChild" newChild="pi"/> |
| <replaceChild obj="doc" var="replacedNode" oldChild="pi" newChild="comment"/> |
| <assertNotNull actual="replacedNode" id="returnValueNotNull"/> |
| <nodeName var="nodeName" obj="replacedNode"/> |
| <assertEquals actual="nodeName" expected='"PITarget"' id="returnValueIsPI" ignoreCase="false"/> |
| <lastChild var="lastChild" obj="doc" interface="Node"/> |
| <assertNotNull actual="lastChild" id="lastChildNotNull"/> |
| <nodeName var="nodeName" obj="lastChild"/> |
| <assertEquals actual="nodeName" expected='"#comment"' id="lastChildIsComment" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild13.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild13"> |
| <metadata> |
| <title>nodereplacechild13</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on this Document node attempt to replace this DocumentType node with |
| a new DocumentType and verify the name of the replaced DocumentType node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="newDocType" type="DocumentType"/> |
| <var name="replaced" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nullPubId" type="DOMString" isNull="true"/> |
| <var name="nullSysId" type="DOMString" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemName" type="DOMString"/> |
| <var name="docElemNS" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="docElemName" obj="docElem"/> |
| <namespaceURI var="docElemNS" obj="docElem" interface="Node"/> |
| <doctype var="docType" obj="doc"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="newDocType" obj="domImpl" qualifiedName='docElemName' publicId="nullPubId" systemId="nullSysId"/> |
| <try> |
| <replaceChild var="replaced" obj="doc" oldChild="docType" newChild="newDocType"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <nodeName var="nodeName" obj="replaced"/> |
| <assertEquals actual="nodeName" expected='docElemName' id="nodereplacechild13" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild14.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild14"> |
| <metadata> |
| <title>nodereplacechild14</title> |
| <creator>IBM</creator> |
| <description> |
| The method replaceChild replaces the child node oldChild with newChild in the list of |
| children, and returns the oldChild node. |
| Using replaceChild on the documentElement of a newly created Document node, attempt to replace an |
| element child of this documentElement node with a child that was imported from another document. |
| Verify the nodeName of the replaced element node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="newDoc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="elem2" type="Element"/> |
| <var name="imported" type="Node"/> |
| <var name="replaced" type="Element"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom3:doc1elem"'/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" qualifiedName='"dom3:doc"' namespaceURI='"http://www.w3.org/DOM/test"' doctype="nullDocType"/> |
| <createElementNS var="elem2" obj="newDoc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom3:doc2elem"'/> |
| <importNode var="imported" obj="newDoc" importedNode="elem" deep="true"/> |
| <documentElement var="docElem" obj="newDoc" interface="Document"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="imported"/> |
| <appendChild obj="docElem" var="appendedChild" newChild="elem2"/> |
| <replaceChild var="replaced" obj="docElem" oldChild="elem2" newChild="imported"/> |
| <nodeName var="nodeName" obj="replaced"/> |
| <assertEquals actual="nodeName" expected='"dom3:doc2elem"' id="nodereplacechild14" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild15.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild15"> |
| <metadata> |
| <title>nodereplacechild15</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a DocumentFragment node attempt to replace an Element node with |
| another Element and the replaced element. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="elem" type="Element"/> |
| <var name="elem2" type="Element"/> |
| <var name="replaced" type="Element"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="title" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="rootNS" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <createElementNS var="elem" obj="doc" namespaceURI="rootNS" qualifiedName="rootName"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createElementNS var="elem2" obj="doc" namespaceURI="rootNS" qualifiedName="rootName"/> |
| <setAttribute obj="elem2" name='"title"' value='"new element"'/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="elem2"/> |
| <replaceChild var="replaced" obj="docFrag" oldChild="elem2" newChild="elem"/> |
| <getAttribute var="title" obj="replaced" name='"title"'/> |
| <assertEquals actual="title" expected='"new element"' id="nodereplacechild15" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild16.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild16"> |
| <metadata> |
| <title>nodereplacechild16</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a DocumentFragment node attempt to replace an Element node with |
| another Element and verify the name of the replaced Element node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="replaced" type="Element"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createTextNode var="txt" obj="doc" data='"Comment"'/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="txt"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="elem"/> |
| <replaceChild var="replaced" obj="docFrag" oldChild="elem" newChild="txt"/> |
| <nodeName var="nodeName" obj="replaced"/> |
| <assertEquals actual="nodeName" expected='"dom3:p"' id="nodereplacechild16" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild17.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild17"> |
| <metadata> |
| <title>nodereplacechild17</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a DocumentFragment node attempt to replace a Comment node with |
| a ProcessingInstruction and vice versa verify the data of the replaced nodes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="cmt" type="Comment"/> |
| <var name="replacedCmt" type="Comment"/> |
| <var name="replacedPi" type="ProcessingInstruction"/> |
| <var name="data" type="DOMString"/> |
| <var name="target" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createComment var="cmt" obj="doc" data='"Comment"'/> |
| <createProcessingInstruction var="pi" obj="doc" target='"target"' data='"Comment"'/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="pi"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="cmt"/> |
| <replaceChild var="replacedCmt" obj="docFrag" oldChild="cmt" newChild="pi"/> |
| <data var="data" obj="replacedCmt" interface="CharacterData"/> |
| <assertEquals actual="data" expected='"Comment"' id="nodereplacechild17_1" ignoreCase="false"/> |
| <replaceChild var="replacedPi" obj="docFrag" oldChild="pi" newChild="cmt"/> |
| <target var="target" obj="replacedPi" interface="ProcessingInstruction"/> |
| <assertEquals actual="target" expected='"target"' id="nodereplacechild17_2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild18.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild18"> |
| <metadata> |
| <title>nodereplacechild18</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a DocumentFragment node attempt to replace a CDATASection node with |
| a EntityReference and vice versa verify the data of the replaced nodes. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="replacedCData" type="CDATASection"/> |
| <var name="replacedEref" type="EntityReference"/> |
| <var name="cdataName" type="DOMString"/> |
| <var name="erefName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createCDATASection var="cdata" obj="doc" data='"CDATASection"'/> |
| <createEntityReference var="entRef" obj="doc" name='"alpha"'/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="entRef"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="cdata"/> |
| <replaceChild var="replacedCData" obj="docFrag" oldChild="cdata" newChild="entRef"/> |
| <nodeValue var="cdataName" obj="replacedCData"/> |
| <assertEquals actual="cdataName" expected='"CDATASection"' id="nodereplacechild18_1" ignoreCase="false"/> |
| <replaceChild var="replacedEref" obj="docFrag" oldChild="entRef" newChild="cdata"/> |
| <nodeName var="erefName" obj="replacedEref"/> |
| <assertEquals actual="erefName" expected='"alpha"' id="nodereplacechild18_2" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild19.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild19"> |
| <metadata> |
| <title>nodereplacechild19</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a DocumentFragment node attempt to replace an Element node with |
| its EntityReference child verify the nodeName of the replaced node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="elem" type="Element"/> |
| <var name="replaced" type="Element"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createEntityReference var="entRef" obj="doc" name='"alpha"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="entRef"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="elem"/> |
| <replaceChild var="replaced" obj="docFrag" oldChild="elem" newChild="entRef"/> |
| <nodeName var="nodeName" obj="replaced"/> |
| <assertEquals actual="nodeName" expected='"dom3:p"' id="nodereplacechild19" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild20.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild20"> |
| <metadata> |
| <title>nodereplacechild20</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a DocumentFragment node attempt to replace an Element node with |
| an Attr Node and verify if a HIERARCHY_REQUEST_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="replaced" type="Element"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="elem"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <replaceChild var="replaced" obj="docFrag" oldChild="elem" newChild="attr"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild21.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild21"> |
| <metadata> |
| <title>nodereplacechild21</title> |
| <creator>IBM</creator> |
| <description> |
| The method replaceChild replaces the child node oldChild with newChild in the list of |
| children, and returns the oldChild node. |
| Using replaceChild on this DocumentType node attempt to replace an Entity node with |
| a notation node of retieved from the DTD of another document and verify if a |
| NO_MODIFICATION_ALLOWED_ERR is thrown since DocumentType node is read-only. |
| Also try replacing the docType with an entity node and see if the same exception gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="ent" type="Entity"/> |
| <var name="doc1" type="Document"/> |
| <var name="docType1" type="DocumentType"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="replacedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType" obj="doc" /> |
| <entities var="entitiesMap" obj="docType" /> |
| <getNamedItem var="ent" obj="entitiesMap" name='"alpha"'/> |
| <load var="doc1" href="hc_staff" willBeModified="false"/> |
| <doctype var="docType1" obj="doc1" /> |
| <notations var="notationsMap" obj="docType1" /> |
| <getNamedItem var="notation" obj="notationsMap" name='"notation1"'/> |
| <assertDOMException id="NO_MODIFICATION_ALLOWED_ERR1_nodereplacechild21"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="docType" var="replacedChild" oldChild="ent" newChild="notation"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="NO_MODIFICATION_ALLOWED_ERR2_nodereplacechild21"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="docType" var="replacedChild" oldChild="docType" newChild="ent"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild22.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild22"> |
| <metadata> |
| <title>nodereplacechild22</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a new EntityReference node attempt to replace an EntityReference node with |
| its Element parent, with itself and vice versa verify if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRefMain" type="EntityReference"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="elem" type="Element"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="replacedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createEntityReference var="entRefMain" obj="doc" name='"delta"'/> |
| <createEntityReference var="entRef" obj="doc" name='"beta"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="entRef"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_1"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="entRefMain" var="replacedChild" oldChild="entRef" newChild="elem"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_2"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="entRefMain" var="replacedChild" oldChild="elem" newChild="entRef"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_3"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="entRefMain" var="replacedChild" oldChild="entRef" newChild="entRefMain"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild23.xml |
|---|
| 0,0 → 1,78 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild23"> |
| <metadata> |
| <title>nodereplacechild23</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a new EntityReference node attempt to replace an Element, Text, |
| Comment, ProcessingInstruction and CDATASection nodes with each other and in each case |
| verify if a NO_MODIFICATION_ALLOWED_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="txt" type="Text"/> |
| <var name="elem" type="Element"/> |
| <var name="comment" type="Comment"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="replaced" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:p"'/> |
| <createEntityReference var="entRef" obj="doc" name='"delta"'/> |
| <createTextNode var="txt" obj="doc" data='"Text"'/> |
| <createComment var="comment" obj="doc" data='"Comment"'/> |
| <createCDATASection var="cdata" obj="doc" data='"CDATASection"'/> |
| <createProcessingInstruction var="pi" obj="doc" target='"target"' data='"data"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="entRef"/> |
| <appendChild obj="elem" var="appendedChild" newChild="txt"/> |
| <appendChild obj="elem" var="appendedChild" newChild="comment"/> |
| <appendChild obj="elem" var="appendedChild" newChild="pi"/> |
| <appendChild obj="elem" var="appendedChild" newChild="cdata"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_1"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="entRef" var="replaced" oldChild="elem" newChild="cdata"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_2"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="entRef" var="replaced" oldChild="cdata" newChild="pi"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_3"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="entRef" var="replaced" oldChild="pi" newChild="comment"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_4"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="entRef" var="replaced" oldChild="comment" newChild="txt"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR_5"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="entRef" var="replaced" oldChild="txt" newChild="elem"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild24.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild24"> |
| <metadata> |
| <title>nodereplacechild24</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on an EntityReference node attempt to replace an Element node with |
| an EntityReference node verify if a NO_MODIFICATION_ALLOWED_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="elem" type="Element"/> |
| <var name="replaced" type="Element"/> |
| <var name="nodeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="childList" index="1" interface="NodeList"/> |
| <firstChild var="entRef" obj="elem" interface="Node"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild var="replaced" obj="entRef" oldChild="elem" newChild="entRef"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild25.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild25"> |
| <metadata> |
| <title>nodereplacechild25</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on an Element node attempt to replace an |
| EntityReference or Text child node |
| with an Entity node and with itself and verify if a HIERARCHY_REQUEST_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="childList" type="NodeList"/> |
| <var name="entRef" type="Node"/> |
| <var name="elem" type="Element"/> |
| <var name="replaced" type="Element"/> |
| <var name="nodeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entities" obj="docType"/> |
| <getNamedItem var="entity" obj="entities" name='"alpha"'/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="childList" index="1" interface="NodeList"/> |
| <firstChild var="entRef" obj="elem" interface="Node"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR_1"> |
| <HIERARCHY_REQUEST_ERR> |
| <replaceChild var="replaced" obj="elem" oldChild="entRef" newChild="entity"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR_2"> |
| <HIERARCHY_REQUEST_ERR> |
| <replaceChild var="replaced" obj="elem" oldChild="entRef" newChild="elem"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild26.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild26"> |
| <metadata> |
| <title>nodereplacechild26</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on an Element node attempt to replace a Text child node with an Element |
| node that is an ancestor of this Element node and verify if a HIERARCHY_REQUEST_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="docElem" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="firstChild" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="childList" index="0" interface="NodeList"/> |
| <firstChild var="firstChild" obj="elem" interface="Node"/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <replaceChild obj="elem" var="replaced" oldChild="firstChild" newChild="docElem"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild27.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild27"> |
| <metadata> |
| <title>nodereplacechild27</title> |
| <creator>IBM</creator> |
| <description> |
| The method replaceChild replaces the child node oldChild with newChild in the list of |
| children, and returns the oldChild node. |
| Using replaceChild on an Element node attempt to replace an Element node with another |
| Element from another document and verify if a WRONG_DOCUMENT_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="childList2" type="NodeList"/> |
| <var name="elem2" type="Element"/> |
| <var name="elem" type="Element"/> |
| <var name="firstChild" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI='"*"' localName='"p"' interface="Document"/> |
| <item var="elem" obj="childList" index="0" interface="NodeList"/> |
| <firstChild var="firstChild" obj="elem" interface="Node"/> |
| <load var="doc2" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagNameNS var="childList2" obj="doc2" namespaceURI='"*"' localName='"p"' interface="Document"/> |
| <item var="elem2" obj="childList2" index="0" interface="NodeList"/> |
| <assertDOMException id="WRONG_DOCUMENT_ERR_nodereplacechild27"> |
| <WRONG_DOCUMENT_ERR> |
| <replaceChild obj="elem" var="replaced" oldChild="firstChild" newChild="elem2"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild28.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild28"> |
| <metadata> |
| <title>nodereplacechild28</title> |
| <creator>IBM</creator> |
| <description> |
| Attempt to replace a text node with a text node from an |
| entity reference. Since the replacing text node should be removed |
| from its current location first, a NO_MODIFICATION_ALLOWED_ERR should |
| be thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="acronym" type="Element"/> |
| <var name="betaRef" type="EntityReference"/> |
| <var name="dallas" type="Text"/> |
| <var name="betaText" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="replacedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronym" obj="childList" index="1" interface="NodeList"/> |
| <firstChild var="betaRef" obj="acronym" interface="Node"/> |
| <assertNotNull actual="betaRef" id="betaRefNotNull"/> |
| <firstChild var="betaText" obj="betaRef" interface="Node"/> |
| <assertNotNull actual="betaText" id="betaTextNotNull"/> |
| <nextSibling var="dallas" obj="betaRef" interface="Node"/> |
| <assertNotNull actual="dallas" id="dallasNotNull"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="acronym" var="replacedChild" oldChild="dallas" newChild="betaText"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild29.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild29"> |
| <metadata> |
| <title>nodereplacechild29</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on an Element node attempt to replace a new Element node with |
| another new Element node and verify if a NOT_FOUND_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="oldChild" type="Element"/> |
| <var name="newChild" type="Element"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="childList" index="0" interface="NodeList"/> |
| <createElementNS var="oldChild" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:br"'/> |
| <createElementNS var="newChild" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"dom3:span"'/> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <replaceChild obj="elem" var="replaced" oldChild="oldChild" newChild="newChild"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild30.xml |
|---|
| 0,0 → 1,89 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild30"> |
| <metadata> |
| <title>nodereplacechild30</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on an Element node attempt to replace a new Element child node with |
| new child nodes and vice versa and in each case verify the name of the replaced node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parent" type="Element"/> |
| <var name="oldChild" type="Element"/> |
| <var name="newElement" type="Element"/> |
| <var name="newText" type="Text"/> |
| <var name="newComment" type="Comment"/> |
| <var name="newPI" type="ProcessingInstruction"/> |
| <var name="newCdata" type="CDATASection"/> |
| <var name="newERef" type="EntityReference"/> |
| <var name="replaced" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:html"'/> |
| <createElementNS var="oldChild" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:head"'/> |
| <createElementNS var="newElement" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:body"'/> |
| <appendChild obj="parent" var="appendedChild" newChild="oldChild"/> |
| <appendChild obj="parent" var="appendedChild" newChild="newElement"/> |
| <createTextNode var="newText" obj="doc" data='"Text"' /> |
| <appendChild obj="parent" var="appendedChild" newChild="newText"/> |
| <createComment var="newComment" obj="doc" data='"Comment"' /> |
| <appendChild obj="parent" var="appendedChild" newChild="newComment"/> |
| <createProcessingInstruction var="newPI" obj="doc" target='"target"' data='"data"' /> |
| <appendChild obj="parent" var="appendedChild" newChild="newPI"/> |
| <createCDATASection var="newCdata" obj="doc" data='"Cdata"' /> |
| <appendChild obj="parent" var="appendedChild" newChild="newCdata"/> |
| <createEntityReference var="newERef" obj="doc" name='"delta"' /> |
| <appendChild obj="parent" var="appendedChild" newChild="newERef"/> |
| <replaceChild var="replaced" obj="parent" oldChild="oldChild" newChild="newElement"/> |
| <nodeName var="nodeName" obj="replaced" /> |
| <assertEquals actual="nodeName" expected='"xhtml:head"' id="nodereplacechild30_1" ignoreCase="false"/> |
| <replaceChild var="replaced" obj="parent" oldChild="newElement" newChild="oldChild"/> |
| <nodeName var="nodeName" obj="replaced" /> |
| <assertEquals actual="nodeName" expected='"xhtml:body"' id="nodereplacechild30_2" ignoreCase="false"/> |
| <replaceChild var="replaced" obj="parent" oldChild="oldChild" newChild="newText"/> |
| <nodeName var="nodeName" obj="replaced" /> |
| <assertEquals actual="nodeName" expected='"xhtml:head"' id="nodereplacechild30_3" ignoreCase="false"/> |
| <replaceChild var="replaced" obj="parent" oldChild="newText" newChild="oldChild"/> |
| <nodeName var="nodeName" obj="replaced" /> |
| <assertEquals actual="nodeName" expected='"#text"' id="nodereplacechild30_4" ignoreCase="false"/> |
| <replaceChild var="replaced" obj="parent" oldChild="oldChild" newChild="newComment"/> |
| <nodeName var="nodeName" obj="replaced" /> |
| <assertEquals actual="nodeName" expected='"xhtml:head"' id="nodereplacechild30_5" ignoreCase="false"/> |
| <replaceChild var="replaced" obj="parent" oldChild="newComment" newChild="oldChild"/> |
| <nodeName var="nodeName" obj="replaced" /> |
| <assertEquals actual="nodeName" expected='"#comment"' id="nodereplacechild30_6" ignoreCase="false"/> |
| <replaceChild var="replaced" obj="parent" oldChild="newPI" newChild="oldChild"/> |
| <nodeName var="nodeName" obj="replaced" /> |
| <assertEquals actual="nodeName" expected='"target"' id="nodereplacechild30_7" ignoreCase="false"/> |
| <replaceChild var="replaced" obj="parent" oldChild="newCdata" newChild="oldChild"/> |
| <nodeName var="nodeName" obj="replaced" /> |
| <assertEquals actual="nodeName" expected='"#cdata-section"' id="nodereplacechild30_8" ignoreCase="false"/> |
| <replaceChild var="replaced" obj="parent" oldChild="newERef" newChild="oldChild"/> |
| <nodeName var="nodeName" obj="replaced" /> |
| <assertEquals actual="nodeName" expected='"delta"' id="nodereplacechild30_9" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild31.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild31"> |
| <metadata> |
| <title>nodereplacechild31</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on an Element node that is the replacement Text of an EntityReference |
| node, attempt to replace its Text child node with a new Element node and verify if |
| a NO_MODIFICATION_ALLOWED_ERR gets thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="span" type="Element"/> |
| <var name="ent4Ref" type="EntityReference"/> |
| <var name="spanText" type="Text"/> |
| <var name="newChild" type="Element"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="childList" obj="doc" tagname='"var"' interface="Document"/> |
| <item var="elem" obj="childList" index="2" interface="NodeList"/> |
| <firstChild var="ent4Ref" obj="elem" interface="Node"/> |
| <firstChild var="span" obj="ent4Ref" interface="Node"/> |
| <assertNotNull actual="span" id="spanNotNull"/> |
| <firstChild var="spanText" obj="span" interface="Node"/> |
| <assertNotNull actual="spanText" id="spanTextNotNull"/> |
| <createElementNS var="newChild" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:p"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="span" var="replaced" oldChild="spanText" newChild="newChild"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild32.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild32"> |
| <metadata> |
| <title>nodereplacechild32</title> |
| <creator>IBM</creator> |
| <description> |
| The method replaceChild replaces the child node oldChild with newChild in the list of |
| children, and returns the oldChild node. |
| Using replaceChild on an Attr node to replace its EntityReference Child with a |
| new Text Node and verify the name of the replaced child. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="parent" type="Attr"/> |
| <var name="oldChild" type="Node"/> |
| <var name="newChild" type="Text"/> |
| <var name="replaced" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="enRef" type="EntityReference"/> |
| <var name="enRefChild" type="EntityReference"/> |
| <var name="reference" type="DOMString" value='"entity1"'/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createTextNode var="newChild" obj="doc" data='"Text"' /> |
| <getElementsByTagNameNS var="childList" obj="doc" namespaceURI='"*"' localName='"acronym"' interface="Document"/> |
| <item var="elem" obj="childList" index="3" interface="NodeList"/> |
| <getAttributeNode var="parent" obj="elem" name='"class"'/> |
| <createEntityReference var="enRef" obj="doc" name="reference"/> |
| <appendChild var="enRefChild" obj="parent" newChild="enRef"/> |
| <replaceChild var="replaced" obj="parent" oldChild="enRefChild" newChild="newChild"/> |
| <nodeName var="nodeName" obj="replaced" /> |
| <assertEquals actual="nodeName" expected='"entity1"' id="nodereplacechild32" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild33.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild33"> |
| <metadata> |
| <title>nodereplacechild33</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a default Attr node to replace its Text Child with a |
| new EntityReference Node and verify the value of the replaced child. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="childList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="parent" type="Attr"/> |
| <var name="oldChild" type="Node"/> |
| <var name="newChild" type="EntityReference"/> |
| <var name="replaced" type="Node"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createEntityReference var="newChild" obj="doc" name='"delta"' /> |
| <getElementsByTagName var="childList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="childList" index="3" interface="NodeList"/> |
| <getAttributeNode var="parent" obj="elem" name='"dir"'/> |
| <lastChild var="oldChild" obj="parent" interface="Node"/> |
| <replaceChild var="replaced" obj="parent" oldChild="oldChild" newChild="newChild"/> |
| <nodeValue var="nodeValue" obj="replaced" /> |
| <assertEquals actual="nodeValue" expected='"rtl"' id="nodereplacechild33" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild34.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild34"> |
| <metadata> |
| <title>nodereplacechild34</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a new Attr node, replace its new EntityReference Child with a |
| new Text Node and verify the value of the new child. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parent" type="Attr"/> |
| <var name="oldChild" type="EntityReference"/> |
| <var name="newChild" type="Text"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttributeNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <createEntityReference var="oldChild" obj="doc" name='"delta"' /> |
| <appendChild obj="parent" var="appendedChild" newChild="oldChild"/> |
| <createTextNode var="newChild" obj="doc" data='"Text"' /> |
| <replaceChild obj="parent" var="replaced" oldChild="oldChild" newChild="newChild"/> |
| <value var="nodeValue" obj="parent" /> |
| <assertEquals actual="nodeValue" expected='"Text"' id="nodereplacechild34" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild35.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild35"> |
| <metadata> |
| <title>nodereplacechild35</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a new Attr node, replace its new EntityRefernece Child with a |
| new Attr Node and verify if a HIERARCHY_REQUEST_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parent" type="Attr"/> |
| <var name="oldChild" type="EntityReference"/> |
| <var name="newChild" type="Attr"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttributeNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <createEntityReference var="oldChild" obj="doc" name='"delta"' /> |
| <appendChild obj="parent" var="appendedChild" newChild="oldChild"/> |
| <createAttributeNS var="newChild" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <assertDOMException id="throw_HIERARCHY_REQUEST_ERR"> |
| <HIERARCHY_REQUEST_ERR> |
| <replaceChild obj="parent" var="replaced" oldChild="oldChild" newChild="newChild"/> |
| </HIERARCHY_REQUEST_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild36.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild36"> |
| <metadata> |
| <title>nodereplacechild36</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a new Attr node, replace its new EntityRefernece node with a |
| new Text Node and verify if a NOT_FOUND_ERR is thrown. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="parent" type="Attr"/> |
| <var name="oldChild" type="EntityReference"/> |
| <var name="newChild" type="Text"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createAttributeNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <createEntityReference var="oldChild" obj="doc" name='"delta"' /> |
| <createTextNode var="newChild" obj="doc" data='"Text"' /> |
| <assertDOMException id="throw_NOT_FOUND_ERR"> |
| <NOT_FOUND_ERR> |
| <replaceChild obj="parent" var="replaced" oldChild="oldChild" newChild="newChild"/> |
| </NOT_FOUND_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild37.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild37"> |
| <metadata> |
| <title>nodereplacechild37</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on a new Attr node, replace its new Text node with a |
| new EntityReference Node created by another document and verify if a |
| WRONG_DOCUMENT_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="parent" type="Attr"/> |
| <var name="oldChild" type="Text"/> |
| <var name="newChild" type="EntityReference"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="replaced" type="Node"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <load var="doc2" href="hc_staff" willBeModified="true"/> |
| <createAttributeNS var="parent" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <createTextNode var="oldChild" obj="doc" data='"Text"' /> |
| <createEntityReference var="newChild" obj="doc2" name='"delta"' /> |
| <appendChild obj="parent" var="appendedChild" newChild="oldChild"/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <replaceChild obj="parent" var="replaced" oldChild="oldChild" newChild="newChild"/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild38.xml |
|---|
| 0,0 → 1,87 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild38"> |
| <metadata> |
| <title>nodereplacechild38</title> |
| <creator>IBM</creator> |
| <description> |
| Using replaceChild on an Entity node attempt to replace its Text child with new Text, |
| Comment, ProcessingInstruction and CDATASection nodes and in each case verify if |
| a NO_MODIFICATION_ALLOWED_ERR is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entitiesMap" type="NamedNodeMap"/> |
| <var name="ent" type="Entity"/> |
| <var name="oldChild" type="Text"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="txt" type="Text"/> |
| <var name="elem" type="Element"/> |
| <var name="comment" type="Comment"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="replaced" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc" /> |
| <entities var="entitiesMap" obj="docType" /> |
| <getNamedItem var="ent" obj="entitiesMap" name='"alpha"'/> |
| <assertNotNull actual="ent" id="alphaEntity"/> |
| <firstChild var="oldChild" obj="ent" interface="Node"/> |
| <assertNotNull actual="oldChild" id="alphaText"/> |
| <createCDATASection var="cdata" obj="doc" data='"CDATASection"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR1"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="ent" var="replaced" oldChild="oldChild" newChild="cdata"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <createProcessingInstruction var="pi" obj="doc" target='"target"' data='"data"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR2"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="ent" var="replaced" oldChild="oldChild" newChild="pi"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <createComment var="comment" obj="doc" data='"Comment"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR3"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="ent" var="replaced" oldChild="oldChild" newChild="comment"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <createTextNode var="txt" obj="doc" data='"Text"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR4"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="ent" var="replaced" oldChild="oldChild" newChild="txt"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:p"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR5"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="ent" var="replaced" oldChild="oldChild" newChild="elem"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| <createEntityReference var="entRef" obj="doc" name='"delta"'/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR6"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceChild obj="ent" var="replaced" oldChild="oldChild" newChild="entRef"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild39.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild39"> |
| <metadata> |
| <title>nodereplacechild39</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to add a second document element by a replacing a trailing comment. The attempt should result |
| in a HIERARCHY_REQUEST_ERR or NOT_SUPPORTED_ERR. |
| </description> |
| <date qualifier="created">2004-01-22</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="newComment" type="Comment"/> |
| <var name="newElement" type="Element"/> |
| <var name="retNode" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <createElementNS var="newElement" obj="doc" namespaceURI="rootNS" qualifiedName="rootName"/> |
| <createComment var="newComment" obj="doc" data='"second element goes here"'/> |
| <appendChild var="retNode" obj="doc" newChild="newComment"/> |
| <try> |
| <replaceChild var="retNode" obj="doc" newChild="newElement" oldChild="newComment"/> |
| <fail id="throw_HIERARCHY_REQUEST_OR_NOT_SUPPORTED"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NOT_SUPPORTED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodereplacechild40.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodereplacechild40"> |
| <metadata> |
| <title>nodereplacechild40</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to add a second document element by a comment. The attempt should result |
| in a HIERARCHY_REQUEST_ERR or NOT_SUPPORTED_ERR. |
| </description> |
| <date qualifier="created">2004-01-22</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-785887307"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="publicId" type="DOMString" isNull="true"/> |
| <var name="systemId" type="DOMString" isNull="true"/> |
| <var name="newComment" type="Comment"/> |
| <var name="newDocType" type="DocumentType"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="retNode" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="rootName" obj="docElem"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocumentType var="newDocType" obj="domImpl" qualifiedName="rootName" |
| publicId="publicId" systemId="systemId"/> |
| <createComment var="newComment" obj="doc" data='"second element goes here"'/> |
| <insertBefore var="retNode" obj="doc" newChild="newComment" refChild="docElem"/> |
| <try> |
| <replaceChild var="retNode" obj="doc" newChild="newDocType" oldChild="newComment"/> |
| <fail id="throw_HIERARCHY_REQUEST_OR_NOT_SUPPORTED"/> |
| <catch> |
| <DOMException code="HIERARCHY_REQUEST_ERR"/> |
| <DOMException code="NOT_SUPPORTED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent01"> |
| <metadata> |
| <title>nodesettextcontent01</title> |
| <creator>IBM</creator> |
| <description> |
| Attempt to set textContent for a Document node and check that the document appears |
| to be unaffected. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <textContent value='"textContent"' obj="doc"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <assertNotNull actual="elem" id="stillHasAcronyms"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"acronym"' id="nodesettextcontent01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent02.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent02"> |
| <metadata> |
| <title>nodesettextcontent02</title> |
| <creator>IBM</creator> |
| <description> |
| The method setTextContent has no effect when the node is defined to be null. |
| Using setTextContent on a new Document node, attempt to set the textContent of this |
| new Document node to textContent. Check if it was not set by checking the nodeName |
| attribute of a new Element of this Document node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="newDoc" type="Document"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="elemChild" type="Element"/> |
| <var name="newElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="documentElem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <implementation var="domImpl" obj="doc"/> |
| <createDocument var="newDoc" obj="domImpl" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom3:elem"' doctype="nullDocType"/> |
| <createElementNS var="newElem" obj="newDoc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom3:childElem"'/> |
| <documentElement var="documentElem" obj="newDoc" interface="Document"/> |
| <appendChild obj="documentElem" var="appendedChild" newChild="newElem"/> |
| <textContent value='"textContent"' obj="newDoc"/> |
| <getElementsByTagNameNS var="elemList" obj="newDoc" localName='"childElem"' namespaceURI='"*"' interface="Document"/> |
| <item var="elemChild" obj="elemList" index="0" interface="NodeList"/> |
| <nodeName var="nodeName" obj="elemChild"/> |
| <assertEquals actual="nodeName" expected='"dom3:childElem"' id="nodesettextcontent02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent03.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent03"> |
| <metadata> |
| <title>nodesettextcontent03</title> |
| <creator>IBM</creator> |
| <description> |
| Using setTextContent on this DocumentType node, attempt to set the textContent of this |
| DocumentType node to textContent. Retreive the textContent and verify if it is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <textContent value='"textContent"' obj="docType"/> |
| <textContent var="textContent" obj="docType"/> |
| <assertNull actual="textContent" id="nodesettextcontent03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent04.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent04"> |
| <metadata> |
| <title>nodesettextcontent04</title> |
| <creator>IBM</creator> |
| <description> |
| Using setTextContent on this DocumentType node, attempt to set the textContent of a |
| Notation node to textContent. Retreive the textContent and verify if it is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notationsMap" type="NamedNodeMap"/> |
| <var name="notation1" type="Notation"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notationsMap" obj="docType"/> |
| <getNamedItem var="notation1" obj="notationsMap" name='"notation1"'/> |
| <textContent value='"textContent"' obj="notation1"/> |
| <textContent var="textContent" obj="notation1"/> |
| <assertNull actual="textContent" id="nodesettextcontent04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent05.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent05"> |
| <metadata> |
| <title>nodesettextcontent05</title> |
| <creator>IBM</creator> |
| <description> |
| Using setTextContent on a default Attr node, attempt to set its value to NA. Retreive |
| the textContent and verify if it is was set to NA. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="elem" name='"dir"'/> |
| <textContent obj="attr" value='"NA"'/> |
| <textContent var="textContent" obj="attr"/> |
| <assertEquals actual="textContent" expected='"NA"' id="nodesettextcontent05" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent06.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent06"> |
| <metadata> |
| <title>nodesettextcontent06</title> |
| <creator>IBM</creator> |
| <description> |
| Using setTextContent on a new Attr node with a null value, attempt to set its value to NA. Retreive |
| the textContent and verify if it is was set to NA. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrNode" type="Attr"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"'/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"xml:lang"'/> |
| <setAttributeNodeNS obj="elem" var="attrNode" newAttr="attr"/> |
| <textContent obj="attr" value='"NA"'/> |
| <textContent var="textContent" obj="attr"/> |
| <assertEquals actual="textContent" expected='"NA"' id="nodesettextcontent06" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent07.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent07"> |
| <metadata> |
| <title>nodesettextcontent07</title> |
| <creator>IBM</creator> |
| <description> |
| Using setTextContent on an existing Text node, attempt to set its value to Text. |
| Retreive the textContent and verify if it is was set to Text. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <firstChild var="txt" obj="elem" interface="Node"/> |
| <textContent obj="txt" value='"Text"'/> |
| <textContent var="textContent" obj="txt"/> |
| <assertEquals actual="textContent" expected='"Text"' id="nodegettextcontent10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent08.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent08"> |
| <metadata> |
| <title>nodesettextcontent08</title> |
| <creator>IBM</creator> |
| <description> |
| Using setTextContent on a new Processing Instruction node, attempt to set its data to PID. |
| Retreive the textContent and verify if it is was set to PID. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:p"'/> |
| <createProcessingInstruction var="pi" obj="doc" target='"PIT"' data='"PID"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="pi"/> |
| <textContent obj="pi" value='"PID"'/> |
| <textContent var="textContent" obj="pi"/> |
| <assertEquals actual="textContent" expected='"PID"' id="nodesettextcontent08" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent10.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent10"> |
| <metadata> |
| <title>nodesettextcontent10</title> |
| <creator>IBM</creator> |
| <description> |
| The method setTextContent has no effect when the node is defined to be null. |
| Using setTextContent on a new Element node, attempt to set its content to ELEMENT. |
| Retreive the textContent and verify if it is was set to ELEMENT. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="comment" type="Comment"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/DOM/Test"' qualifiedName='"dom3:elem"'/> |
| <createTextNode var="txt" obj="doc" data='"Text "' /> |
| <createComment var="comment" obj="doc" data='"Comment "' /> |
| <createEntityReference var="entRef" obj="doc" name='"ent1"' /> |
| <createProcessingInstruction var="pi" obj="doc" target='"PIT"' data='"PIData "'/> |
| <createCDATASection var="cdata" obj="doc" data='"CData"' /> |
| <appendChild obj="elem" var="appendedChild" newChild="txt"/> |
| <appendChild obj="elem" var="appendedChild" newChild="comment"/> |
| <appendChild obj="elem" var="appendedChild" newChild="entRef"/> |
| <appendChild obj="elem" var="appendedChild" newChild="pi"/> |
| <appendChild obj="elem" var="appendedChild" newChild="cdata"/> |
| <textContent obj="elem" value='"ELEMENT"'/> |
| <textContent var="textContent" obj="elem"/> |
| <assertEquals actual="textContent" expected='"ELEMENT"' id="nodesettextcontent10" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent11.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent11"> |
| <metadata> |
| <title>nodesettextcontent11</title> |
| <creator>IBM</creator> |
| <description> |
| Using setTextContent on a new DocumentFragment node Element child, attempt to set its content to |
| DOCUMENTFRAGMENT. Retreive the textContent and verify if it is was set to DOCUMENTFRAGMENT |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docFrag" type="DocumentFragment"/> |
| <var name="elem" type="Element"/> |
| <var name="elemChild" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="comment" type="Comment"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="cdata" type="CDATASection"/> |
| <var name="pi" type="ProcessingInstruction"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createDocumentFragment var="docFrag" obj="doc"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:p"'/> |
| <createTextNode var="txt" obj="doc" data='"Text "' /> |
| <createComment var="comment" obj="doc" data='"Comment "' /> |
| <createEntityReference var="entRef" obj="doc" name='"alpha"' /> |
| <createProcessingInstruction var="pi" obj="doc" target='"PIT"' data='"PIData "'/> |
| <createCDATASection var="cdata" obj="doc" data='"CData"' /> |
| <appendChild obj="elem" var="appendedChild" newChild="txt"/> |
| <appendChild obj="elem" var="appendedChild" newChild="comment"/> |
| <appendChild obj="elem" var="appendedChild" newChild="entRef"/> |
| <appendChild obj="elem" var="appendedChild" newChild="pi"/> |
| <appendChild obj="elem" var="appendedChild" newChild="cdata"/> |
| <appendChild obj="docFrag" var="appendedChild" newChild="elem"/> |
| <textContent obj="elem" value='"DOCUMENTFRAGMENT"'/> |
| <lastChild var="elemChild" obj="docFrag" interface="Node"/> |
| <textContent var="textContent" obj="elemChild"/> |
| <assertEquals actual="textContent" expected='"DOCUMENTFRAGMENT"' id="nodegettextcontent11" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent12.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent12"> |
| <metadata> |
| <title>nodesettextcontent12</title> |
| <creator>IBM</creator> |
| <description> |
| Using setTextContent on a new EntityReference node, attempt to set its value. |
| Since EntityReference nodes are ReadOnly, check if a NO_MODIFICATION_ALLOWED_ERR |
| is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="textContent" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="elem" obj="doc"/> |
| <createEntityReference var="entRef" obj="doc" name='"beta"' /> |
| <appendChild obj="elem" var="appendedChild" newChild="entRef"/> |
| <assertDOMException id="nodesettextcontent12"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <textContent obj="entRef" value='"NA"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesettextcontent13.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesettextcontent13"> |
| <metadata> |
| <title>nodesettextcontent13</title> |
| <creator>IBM</creator> |
| <description> |
| Using setTextContent on an Entity node, attempt to set its replacement text. |
| Since Entity nodes are ReadOnly, check if a NO_MODIFICATION_ALLOWED_ERR |
| is raised. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-textContent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entity" type="Entity"/> |
| <var name="entitymap" type="NamedNodeMap"/> |
| <var name="textContent" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entitymap" obj="docType"/> |
| <getNamedItem var="entity" obj="entitymap" name='"delta"'/> |
| <assertDOMException id="nodesettextcontent13"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <textContent value='"NA"' obj="entity"/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesetuserdata01.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesetuserdata01"> |
| <metadata> |
| <title>nodesetuserdata01</title> |
| <creator>IBM</creator> |
| <description> |
| Using setUserData with null values for the UserData and the handler parameters, check |
| if returned the current userData object of this Document node is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-setUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="prevUserData" type="DOMUserData"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <var name="nullData" type="DOMUserData" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <setUserData var="prevUserData" obj="doc" key='"something"' data="nullData" handler="nullHandler"/> |
| <assertNull actual="prevUserData" id="nodesetuserdata01"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesetuserdata02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesetuserdata02"> |
| <metadata> |
| <title>nodesetuserdata02</title> |
| <creator>IBM</creator> |
| <description> |
| Using setUserData with values for the UserData as this Document and the handler as null |
| parameters, check if returned the current userData object of this Document node is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-setUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="prevUserData" type="DOMUserData"/> |
| <var name="test" type="DOMUserData" isNull="true"/> |
| <var name="str" type="DOMString" value='"Junk"'/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <setUserData var="prevUserData" obj="doc" key='"something"' data="test" handler="nullHandler"/> |
| <assertNull actual="prevUserData" id="nodesetuserdata02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesetuserdata03.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesetuserdata03"> |
| <metadata> |
| <title>nodesetuserdata03</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on this Document to set this Documents UserData to a new |
| Element node. Do the same with a new Text node and using isNodeEqual verify |
| the returned Element UserData object. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-setUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="returnedUserData" type="DOMUserData"/> |
| <var name="success" type="boolean"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"xhtml:p"' /> |
| <createTextNode var="txt" obj="doc" data='"TEXT"' /> |
| <setUserData obj="doc" var="returnedUserData" key='"Key1"' data="elem" handler="nullHandler"/> |
| <setUserData var="retUserData" obj="doc" key='"Key1"' data="txt" handler="nullHandler"/> |
| <isEqualNode var="success" obj="retUserData" arg="elem"/> |
| <assertTrue actual="success" id="nodesetuserdata03"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesetuserdata04.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesetuserdata04"> |
| <metadata> |
| <title>nodesetuserdata04</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on a new Element to set its UserData to a new Text node |
| twice using different Keys. Using getUserData with each Key and isNodeEqual |
| verify if the returned nodes are Equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-setUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="returned1" type="DOMUserData"/> |
| <var name="returned2" type="DOMUserData"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="success" type="boolean"/> |
| <var name="elem" type="Element"/> |
| <var name="txt" type="Text"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"' /> |
| <createTextNode var="txt" obj="doc" data='"TEXT"' /> |
| <setUserData obj="elem" var="retUserData" key='"Key1"' data="txt" handler="nullHandler"/> |
| <setUserData obj="elem" var="retUserData" key='"Key2"' data="txt" handler="nullHandler"/> |
| <getUserData var="returned1" obj="elem" key='"Key1"'/> |
| <getUserData var="returned2" obj="elem" key='"Key2"'/> |
| <isEqualNode var="success" obj="returned1" arg="returned2"/> |
| <assertTrue actual="success" id="nodesetuserdata04"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesetuserdata05.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesetuserdata05"> |
| <metadata> |
| <title>nodesetuserdata05</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on a new Attr to set its UserData to two Document nodes |
| obtained by parsing the same xml document. Using getUserData and isNodeEqual |
| verify if the returned nodes are Equal. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-setUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="doc2" type="Document"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="returned1" type="DOMUserData"/> |
| <var name="returned2" type="DOMUserData"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="success" type="boolean"/> |
| <var name="attr" type="Attr"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <load var="doc2" href="hc_staff" willBeModified="true"/> |
| <createAttributeNS var="attr" obj="doc" namespaceURI='"http://www.w3.org/XML/1998/namespace"' qualifiedName='"lang"' /> |
| <setUserData obj="attr" var="retUserData" key='"Key1"' data="doc" handler="nullHandler"/> |
| <setUserData obj="attr" var="retUserData" key='"Key2"' data="doc2" handler="nullHandler"/> |
| <getUserData var="returned1" obj="attr" key='"Key1"'/> |
| <getUserData var="returned2" obj="attr" key='"Key2"'/> |
| <isEqualNode var="success" obj="returned1" arg="returned2"/> |
| <assertTrue actual="success" id="nodesetuserdata05"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesetuserdata06.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesetuserdata06"> |
| <metadata> |
| <title>nodesetuserdata06</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on a new Comment to set its UserData to an Entity node |
| twice using the same key. Verify if the UserData object that was by the |
| second setUserData is the same as original Entity. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-setUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="comment" type="Comment"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="returned" type="DOMUserData"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="success" type="boolean"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <entities var="entities" obj="docType"/> |
| <getNamedItem var="entity" obj="entities" name='"delta"'/> |
| <createComment var="comment" obj="doc" data='"COMMENT_NODE"' /> |
| <setUserData obj="comment" var="retUserData" key='"Key1"' data="entity" handler="nullHandler"/> |
| <setUserData var="returned" obj="comment" key='"Key1"' data="entity" handler="nullHandler"/> |
| <isEqualNode var="success" obj="returned" arg="entity"/> |
| <assertTrue actual="success" id="nodesetuserdata06"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesetuserdata07.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesetuserdata07"> |
| <metadata> |
| <title>nodesetuserdata07</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on a Notation to set its UserData to a Comment node |
| twice using the same key. Verify if the UserData object that was returned |
| by second setUserData is the Comment node set in the first setUserData call. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-setUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="notations" type="NamedNodeMap"/> |
| <var name="notation" type="Notation"/> |
| <var name="comment" type="Comment"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="returned" type="DOMUserData"/> |
| <var name="success" type="boolean"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <doctype var="docType" obj="doc"/> |
| <notations var="notations" obj="docType"/> |
| <getNamedItem var="notation" obj="notations" name='"notation1"'/> |
| <createComment var="comment" obj="doc" data='"COMMENT_NODE"' /> |
| <setUserData obj="notation" var="retUserData" key='"Key1"' data="comment" handler="nullHandler"/> |
| <setUserData var="returned" obj="notation" key='"Key1"' data="comment" handler="nullHandler"/> |
| <isEqualNode var="success" obj="returned" arg="comment"/> |
| <assertTrue actual="success" id="nodesetuserdata07"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesetuserdata08.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesetuserdata08"> |
| <metadata> |
| <title>nodesetuserdata08</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on a CDATASection and EntityReference node to set their |
| UserData to this Document and DocumentElement node. Verify if the UserData |
| object that was set for both nodes is different. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-setUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="cData" type="CDATASection"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elemName" type="Element"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="returned1" type="DOMUserData"/> |
| <var name="returned2" type="DOMUserData"/> |
| <var name="success" type="boolean"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createEntityReference name='"delta"' obj="doc" var="entRef"/> |
| <createCDATASection var="cData" obj="doc" data='"CDATASection"' /> |
| <setUserData obj="entRef" var="retUserData" key='"Key1"' data="doc" handler="nullHandler"/> |
| <setUserData obj="cData" var="retUserData" key='"Key2"' data="docElem" handler="nullHandler"/> |
| <getUserData var="returned1" obj="entRef" key='"Key1"'/> |
| <getUserData var="returned2" obj="cData" key='"Key2"'/> |
| <isEqualNode var="success" obj="returned1" arg="returned2"/> |
| <assertFalse actual="success" id="nodesetuserdata08"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesetuserdata09.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesetuserdata09"> |
| <metadata> |
| <title>nodesetuserdata09</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on this documentElement node to set its UserData to |
| this Document node. Invoke getUserData on this Document node with the same |
| key of the UserData that was just set on the documentElement node and verify |
| if the returned node is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-setUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="returned" type="DOMUserData"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <setUserData obj="docElem" var="retUserData" key='"Key1"' data="doc" handler="nullHandler"/> |
| <getUserData var="returned" obj="doc" key='"Key1"'/> |
| <assertNull actual="returned" id="nodesetuserdata09"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/nodesetuserdata10.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodesetuserdata10"> |
| <metadata> |
| <title>nodesetuserdata10</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke setUserData on a CDATASection and EntityReference node to set their |
| UserData to this Document and DocumentElement node. Verify if the UserData |
| object that was set for both nodes is different. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-06-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Node3-setUserData"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <!-- could also be Text --> |
| <var name="entRef" type="Node"/> |
| <var name="cData" type="CDATASection"/> |
| <var name="varList" type="NodeList"/> |
| <var name="varElem" type="Element"/> |
| <var name="userData" type="DOMUserData"/> |
| <var name="returned1" type="DOMUserData"/> |
| <var name="returned2" type="DOMUserData"/> |
| <var name="success" type="boolean"/> |
| <var name="retUserData" type="DOMUserData"/> |
| <var name="nullHandler" type="UserDataHandler" isNull="true"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <documentElement var="docElem" obj="doc"/> |
| <getElementsByTagName var="varList" obj="doc" tagname='"var"' interface="Document"/> |
| <item var="varElem" obj="varList" index="2" interface="NodeList"/> |
| <firstChild var="entRef" obj="varElem" interface="Node"/> |
| <createCDATASection var="cData" obj="doc" data='"CDATASection"' /> |
| <setUserData obj="entRef" var="retUserData" key='"Key1"' data="doc" handler="nullHandler"/> |
| <setUserData obj="cData" var="retUserData" key='"Key2"' data="docElem" handler="nullHandler"/> |
| <getUserData var="returned1" obj="entRef" key='"Key1"'/> |
| <getUserData var="returned2" obj="cData" key='"Key2"'/> |
| <isEqualNode var="success" obj="returned1" arg="returned2"/> |
| <assertFalse actual="success" id="nodesetuserdata08"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/normalizecharacters01.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters01"> |
| <metadata> |
| <title>normalizecharacters01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with normalize-characters set to false, check that |
| characters are not normalized. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-normalize-characters"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"barsuçon"' |
| ignoreCase="false" id="noCharNormalization"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/normalizecharacters02.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters02"> |
| <metadata> |
| <title>normalizecharacters02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with normalize-characters set to true, check that |
| characters are normalized. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-normalize-characters"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"normalize-characters"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalizeDocument obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"barsuçon"' |
| ignoreCase="false" id="charNormalized"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/normalizecharacters03.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters03"> |
| <metadata> |
| <title>normalizecharacters03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize an element with normalize-characters set to false, check that |
| characters are not normalized. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-normalize-characters"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalize obj="pElem"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"barsuçon"' |
| ignoreCase="false" id="noCharNormalization"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/normalizecharacters04.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters04"> |
| <metadata> |
| <title>normalizecharacters04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize an element with normalize-characters set to true, check that |
| characters are normalized. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-normalize-characters"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"normalize-characters"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalize obj="pElem"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"barsuçon"' |
| ignoreCase="false" id="noCharNormalization"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/normalizecharacters05.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters05"> |
| <metadata> |
| <title>normalizecharacters05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize an document (using Node.normalize) with normalize-characters set to false, check that |
| characters are not normalized. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-normalize-characters"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalize obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"barsuçon"' |
| ignoreCase="false" id="noCharNormalization"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/normalizecharacters06.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters06"> |
| <metadata> |
| <title>normalizecharacters06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize a document (using Node.normalize) with normalize-characters set to true, check that |
| characters are normalized. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-normalize-characters"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"normalize-characters"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalize obj="doc"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"barsuçon"' |
| ignoreCase="false" id="noCharNormalization"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/normalizecharacters07.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters07"> |
| <metadata> |
| <title>normalizecharacters07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize a text node with normalize-characters set to false, check that |
| characters are not normalized. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-normalize-characters"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalize obj="retval"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <lastChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"suçon"' |
| ignoreCase="false" id="noCharNormalization"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/normalizecharacters08.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters08"> |
| <metadata> |
| <title>normalizecharacters08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize a text node with normalize-characters set to true, check that |
| characters are normalized. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-normalize-characters"/> |
| <subject resource="http://www.w3.org/TR/2003/WD-charmod-20030822/"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="text" type="Text"/> |
| <var name="textValue" type="DOMString"/> |
| <var name="retval" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"normalize-characters"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- character entity is expanded during code generation |
| code equivalent to "suc\u0327on" --> |
| <createTextNode var="text" obj="doc" data='"suçon"'/> |
| <appendChild var="retval" obj="pElem" newChild="text"/> |
| <normalize obj="retval"/> |
| <!-- fail test if normalize had any errors or fatal errors --> |
| <assertLowerSeverity obj="errorMonitor" id="normalizeError" severity="SEVERITY_ERROR"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <lastChild var="text" obj="pElem" interface="Node"/> |
| <nodeValue var="textValue" obj="text"/> |
| <assertEquals actual="textValue" expected='"suçon"' |
| ignoreCase="false" id="noCharNormalization"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/splitcdatasections01.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="splitcdatasections01"> |
| <metadata> |
| <title>splitcdatasections</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Add a CDATASection containing "]]>" and call Node.normalize which should not |
| split or raise warning. |
| </description> |
| <date qualifier="created">2004-02-25</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-normalize"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-split-cdata-sections"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="newChild" type="CDATASection"/> |
| <var name="oldChild" type="Node"/> |
| <var name="retval" type="Node"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <firstChild var="oldChild" obj="elem" interface="Node"/> |
| <createCDATASection var="newChild" obj="doc" data='"this is not ]]> good"'/> |
| <replaceChild var="retval" obj="elem" newChild="newChild" oldChild="oldChild"/> |
| <domConfig obj="doc" var="domConfig" interface="Document"/> |
| <setParameter obj="domConfig" name='"split-cdata-sections"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalize obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="noErrors"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textiselementcontentwhitespace01.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textiselementcontentwhitespace01"> |
| <metadata> |
| <title>textiselementcontentwhitespace01</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke isElementContentWhitespace on a newly created Text Node that contains only whitespace. |
| Should be false since there is no content model to determine if the node appears within element content. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-isElementContentWhitespace"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="newText" type="Text"/> |
| <var name="hasWhitespace" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <createTextNode var="newText" obj="doc" data='" "'/> |
| <isElementContentWhitespace obj="newText" var="hasWhitespace"/> |
| <assertFalse actual="hasWhitespace" id="isWhitespace"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textiselementcontentwhitespace02.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textiselementcontentwhitespace02"> |
| <metadata> |
| <title>textiselementcontentwhitespace02</title> |
| <creator>IBM</creator> |
| <description> |
| Get the text node child of the "p" element in barfoo. isElementContentWhitespace should |
| be false since the node is neither whitespace or in element content. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-isElementContentWhitespace"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="isElemContentWhitespace" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="textNode" obj="pElem" interface="Node"/> |
| <isElementContentWhitespace obj="textNode" var="isElemContentWhitespace"/> |
| <assertFalse actual="isElemContentWhitespace" id="notElemContentOrWhitespace"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textiselementcontentwhitespace03.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textiselementcontentwhitespace03"> |
| <metadata> |
| <title>textiselementcontentwhitespace03</title> |
| <creator>IBM</creator> |
| <description> |
| Get the newline between the "body" and "p" element. Since node is both in element content |
| and whitespace, isElementContentWhitespace should return true. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-isElementContentWhitespace"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="ignoringElementContentWhitespace" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="isElemContentWhitespace" type="boolean"/> |
| <load var="doc" href="barfoo" willBeModified="false"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <!-- should be text node containing new line between "body" and "p" element --> |
| <previousSibling var="textNode" obj="pElem" interface="Node"/> |
| <isElementContentWhitespace obj="textNode" var="isElemContentWhitespace"/> |
| <assertTrue actual="isElemContentWhitespace" id="isElementContentWhitespace"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textiselementcontentwhitespace04.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textiselementcontentwhitespace04"> |
| <metadata> |
| <title>textiselementcontentwhitespace04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Replace the text node child of the "p" element in barfoo with whitespace and normalize with validation. |
| isElementContentWhitespace should be false since the node is not in element content. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2004-01-05</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-isElementContentWhitespace"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="pList" type="NodeList"/> |
| <var name="pElem" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="blankNode" type="Text"/> |
| <var name="returnedNode" type="Node"/> |
| <var name="isElemContentWhitespace" type="boolean"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSetValidation" type="boolean"/> |
| <var name="replacedNode" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <canSetParameter var="canSetValidation" obj="domConfig" name='"validate"' value="true"/> |
| <if> |
| <isTrue value="canSetValidation"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="pElem" obj="pList" index="0" interface="NodeList"/> |
| <firstChild var="textNode" obj="pElem" interface="Node"/> |
| <createTextNode var="blankNode" obj="doc" data='" "'/> |
| <replaceChild var="replacedNode" obj="pElem" newChild="blankNode" oldChild="textNode"/> |
| <normalizeDocument obj="doc"/> |
| <firstChild var="textNode" obj="pElem" interface="Node"/> |
| <isElementContentWhitespace obj="textNode" var="isElemContentWhitespace"/> |
| <assertFalse actual="isElemContentWhitespace" id="notElemContent"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textiselementcontentwhitespace05.xml |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textiselementcontentwhitespace05"> |
| <metadata> |
| <title>textiselementcontentwhitespace05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Replace the whitespace before the "p" element in barfoo with non-whitespace and normalize with validation. |
| isElementContentWhitespace should be false since the node is not whitespace. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2004-01-05</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-isElementContentWhitespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="bodyElem" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="nonBlankNode" type="Text"/> |
| <var name="returnedNode" type="Node"/> |
| <var name="isElemContentWhitespace" type="boolean"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSetValidation" type="boolean"/> |
| <var name="refChild" type="Node"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <canSetParameter var="canSetValidation" obj="domConfig" name='"validate"' value="true"/> |
| <if> |
| <isTrue value="canSetValidation"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <!-- newline between body and p or p --> |
| <firstChild var="refChild" obj="bodyElem" interface="Node"/> |
| <!-- replace with non-blank --> |
| <createTextNode var="nonBlankNode" obj="doc" data='"not blank"'/> |
| <insertBefore var="returnedNode" obj="bodyElem" newChild="nonBlankNode" refChild="refChild"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="noErrors"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <!-- non-blank between body and p --> |
| <firstChild var="textNode" obj="bodyElem" interface="Node"/> |
| <isElementContentWhitespace obj="textNode" var="isElemContentWhitespace"/> |
| <assertFalse actual="isElemContentWhitespace" id="notElemContent"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textiselementcontentwhitespace06.xml |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textiselementcontentwhitespace06"> |
| <metadata> |
| <title>textiselementcontentwhitespace06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Insert whitespace before the "p" element in barfoo and normalize with validation. |
| isElementContentWhitespace should be true since the node is whitespace and in element content. |
| </description> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2004-01-05</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-isElementContentWhitespace"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="bodyElem" type="Element"/> |
| <var name="refChild" type="Node"/> |
| <var name="textNode" type="Text"/> |
| <var name="blankNode" type="Text"/> |
| <var name="returnedNode" type="Node"/> |
| <var name="isElemContentWhitespace" type="boolean"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSetValidation" type="boolean"/> |
| <var name="replacedNode" type="Node"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <canSetParameter var="canSetValidation" obj="domConfig" name='"validate"' value="true"/> |
| <if> |
| <isTrue value="canSetValidation"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <!-- newline between body and p or the p element --> |
| <firstChild var="refChild" obj="bodyElem" interface="Node"/> |
| <!-- replace with different whitespace --> |
| <createTextNode var="blankNode" obj="doc" data='" "'/> |
| <insertBefore var="replacedNode" obj="bodyElem" newChild="blankNode" refChild="refChild"/> |
| <normalizeDocument obj="doc"/> |
| <assertLowerSeverity obj="errorMonitor" severity="SEVERITY_ERROR" id="noErrors"/> |
| <getElementsByTagName var="bodyList" obj="doc" tagname='"body"' interface="Document"/> |
| <item var="bodyElem" obj="bodyList" index="0" interface="NodeList"/> |
| <!-- previously inserted whitespace between body and p --> |
| <firstChild var="textNode" obj="bodyElem" interface="Node"/> |
| <isElementContentWhitespace obj="textNode" var="isElemContentWhitespace"/> |
| <assertTrue actual="isElemContentWhitespace" id="isElemContentWhitespace"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textreplacewholetext01.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textreplacewholetext01"> |
| <metadata> |
| <title>textreplacewholetext01</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke replaceWholeText on an existing Text Node to replace its value with a |
| new value containing white space characters. Verify the replaceWholeText by |
| verifying the values returned by wholeText |
| of the returned Text node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-replaceWholeText"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="itemList" type="NodeList"/> |
| <var name="elementName" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="replacedText" type="Text"/> |
| <var name="wholeText" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="itemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elementName" obj="itemList" index="0" interface="NodeList"/> |
| <firstChild var="textNode" obj="elementName" interface="Node"/> |
| <replaceWholeText obj="textNode" var="replacedText" content='"New Content"'/> |
| <wholeText var="wholeText" obj="replacedText"/> |
| <assertEquals expected='"New Content"' actual="wholeText" id="textreplacewholetext01_1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textreplacewholetext02.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textreplacewholetext02"> |
| <metadata> |
| <title>textreplacewholetext02</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke replaceWholeText on an existing Text Node to replace its value with an |
| empty string value. Verify the repalceWholeText method by verifying if the value |
| returned is null. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-replaceWholeText"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="itemList" type="NodeList"/> |
| <var name="elementName" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="replacedText" type="Text"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="itemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elementName" obj="itemList" index="0" interface="NodeList"/> |
| <firstChild var="textNode" obj="elementName" interface="Node"/> |
| <replaceWholeText obj="textNode" var="replacedText" content='""'/> |
| <assertNull actual="replacedText" id="textreplacewholetext02"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textreplacewholetext03.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textreplacewholetext03"> |
| <metadata> |
| <title>textreplacewholetext03</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke replaceWholeText on an new Text Node to replace its value with a |
| new value. Verify the repalceWholeText by verifying the values returned by |
| wholeText of the returned Text node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-replaceWholeText"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="textNode" type="Text"/> |
| <var name="replacedText" type="Text"/> |
| <var name="wholeText" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createTextNode var="textNode" obj="doc" data='"New Text"'/> |
| <replaceWholeText obj="textNode" var="replacedText" content='" |
| a b c b "'/> |
| <wholeText var="wholeText" obj="replacedText"/> |
| <assertEquals expected='" |
| a b c b "' actual="wholeText" id="textreplacewholetext03" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textreplacewholetext04.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textreplacewholetext04"> |
| <metadata> |
| <title>textreplacewholetext04</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke replaceWholeText on an new Text Node to replace its value with an |
| empty value. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-replaceWholeText"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="textNode" type="Text"/> |
| <var name="replacedText" type="Text"/> |
| <var name="wholeText" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createTextNode var="textNode" obj="doc" data='"New Text"'/> |
| <replaceWholeText obj="textNode" var="replacedText" content='""'/> |
| <assertNull actual="replacedText" id="retvalIsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textreplacewholetext05.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textreplacewholetext05"> |
| <metadata> |
| <title>textreplacewholetext05</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke replaceWholeText on an existing text node with newly created text and CDATASection |
| nodes appended as children of its parent element node. Verify repalceWholeText by |
| verifying the values returned by wholeText. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-replaceWholeText"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="itemList" type="NodeList"/> |
| <var name="elementName" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="cdataNode" type="CDATASection"/> |
| <var name="replacedText" type="Text"/> |
| <var name="wholeText" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="itemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elementName" obj="itemList" index="0" interface="NodeList"/> |
| <createTextNode var="textNode" obj="doc" data='"New Text"'/> |
| <createCDATASection var="cdataNode" obj="doc" data='"New CDATA"'/> |
| <appendChild obj="elementName" var="appendedChild" newChild="textNode"/> |
| <appendChild obj="elementName" var="appendedChild" newChild="cdataNode"/> |
| <firstChild var="textNode" obj="elementName" interface="Node"/> |
| <replaceWholeText obj="textNode" var="replacedText" content='"New Text and Cdata"'/> |
| <wholeText var="wholeText" obj="replacedText"/> |
| <assertEquals expected='"New Text and Cdata"' actual="wholeText" id="textreplacewholetext05" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textreplacewholetext06.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textreplacewholetext06"> |
| <metadata> |
| <title>textreplacewholetext06</title> |
| <creator>IBM</creator> |
| <description> |
| The method replaceWholeText substitutes the a specified text for the text of |
| the current node and all logically-adjacent text nodes. This method raises |
| a NO_MODIFICATION_ALLOWED_ERR if one of the Text nodes being replaced is readonly. |
| Invoke replaceWholeText on an existing text node with newly created text and Entityreference |
| nodes (whose replacement text is a character entity reference) appended as children of its parent element node. |
| Where the nodes to be removed are read-only descendants of an EntityReference, the EntityReference |
| must be removed instead of the read-only nodes. Only if any EntityReference to be removed has |
| descendants that are not EntityReference, Text, or CDATASection nodes, the replaceWholeText |
| method must fail, raising a NO_MODIFICATION_ALLOWED_ERR. Verify that the method does not raise |
| an exception and verify the content of the returned text node. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-replaceWholeText"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="expandEntityReferences" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="itemList" type="NodeList"/> |
| <var name="elementStrong" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="erefNode" type="EntityReference"/> |
| <var name="replacedText" type="Text"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="nodeValue" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="itemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elementStrong" obj="itemList" index="0" interface="NodeList"/> |
| <createTextNode var="textNode" obj="doc" data='"New Text"'/> |
| <createEntityReference var="erefNode" obj="doc" name='"beta"'/> |
| <appendChild obj="elementStrong" var="appendedChild" newChild="textNode"/> |
| <appendChild obj="elementStrong" var="appendedChild" newChild="erefNode"/> |
| <firstChild var="textNode" obj="elementStrong" interface="Node"/> |
| <replaceWholeText obj="textNode" var="replacedText" content='"New Text and Cdata"'/> |
| <nodeValue var="nodeValue" obj="textNode" /> |
| <assertEquals actual="nodeValue" expected='"New Text and Cdata"' id="textreplacewholetext06" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textreplacewholetext07.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textreplacewholetext07"> |
| <metadata> |
| <title>textreplacewholetext07</title> |
| <creator>IBM</creator> |
| <description> |
| Append an entity reference and a text node after to the content of the |
| first strong element. Then call replaceWholeText on initial content |
| of that element. Since the entity reference does not contain any |
| logically-adjacent text content, only the initial text element should |
| be replaced. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <contributor>Curt Arnold</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-replaceWholeText"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=425"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="itemList" type="NodeList"/> |
| <var name="elementName" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="erefNode" type="EntityReference"/> |
| <var name="replacedText" type="Text"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="node" type="Node"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="itemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elementName" obj="itemList" index="0" interface="NodeList"/> |
| <createEntityReference var="erefNode" obj="doc" name='"ent4"'/> |
| <createTextNode var="textNode" obj="doc" data='"New Text"'/> |
| <appendChild obj="elementName" var="appendedChild" newChild="erefNode"/> |
| <appendChild obj="elementName" var="appendedChild" newChild="textNode"/> |
| <firstChild var="textNode" obj="elementName" interface="Node"/> |
| <replaceWholeText obj="textNode" var="replacedText" content='"New Text and Cdata"'/> |
| <firstChild var="textNode" obj="elementName" interface="Node"/> |
| <assertSame expected="textNode" actual="replacedText" id="retval_same"/> |
| <nodeValue var="nodeValue" obj="textNode"/> |
| <assertEquals actual="nodeValue" expected='"New Text and Cdata"' |
| id="nodeValueSame" ignoreCase="false"/> |
| <nextSibling var="node" obj="textNode" interface="Node"/> |
| <assertNotNull actual="node" id="secondChildNotNull"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="5" id="secondChildIsEntRef" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textreplacewholetext08.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textreplacewholetext08"> |
| <metadata> |
| <title>textreplacewholetext08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Appends an entity reference containing text and an element to an existing |
| text node, then calls Text.replaceWholeText on the existing text node. |
| A NO_MODIFICATION_ALLOWED_ERR should be thrown. |
| </description> |
| <date qualifier="created">2003-12-18</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-replaceWholeText"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=425"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=540"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="itemList" type="NodeList"/> |
| <var name="p" type="Element"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="node" type="Node"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="itemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="p" obj="itemList" index="0" interface="NodeList"/> |
| <createEntityReference var="entRef" obj="doc" name='"ent2"'/> |
| <appendChild obj="p" var="node" newChild="entRef"/> |
| <firstChild var="node" obj="p" interface="Node"/> |
| <assertDOMException id="throw_NO_MODIFICATION_ALLOWED_ERR"> |
| <NO_MODIFICATION_ALLOWED_ERR> |
| <replaceWholeText obj="node" var="node" content='"yo"'/> |
| </NO_MODIFICATION_ALLOWED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textwholetext01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textwholetext01"> |
| <metadata> |
| <title>textwholetext01</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke wholetext on an existing Text Node that contains whitespace and verify if |
| the value returned is correct. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-wholeText"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="itemList" type="NodeList"/> |
| <var name="elementName" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="nameWholeText" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="itemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elementName" obj="itemList" index="0" interface="NodeList"/> |
| <firstChild var="textNode" obj="elementName" interface="Node"/> |
| <wholeText obj="textNode" var="nameWholeText"/> |
| <assertEquals expected='"Margaret Martin"' actual="nameWholeText" id="textwholetext01" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textwholetext02.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textwholetext02"> |
| <metadata> |
| <title>textwholetext02</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke wholetext on an existing Text Node that contains whitespace and and verify if |
| the value returned is correct. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-wholeText"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="itemList" type="NodeList"/> |
| <var name="elementName" type="Element"/> |
| <var name="textNode" type="Text"/> |
| <var name="newTextNode" type="Text"/> |
| <var name="wholeText" type="DOMString"/> |
| <var name="appendedChild" type="Node"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <getElementsByTagName var="itemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elementName" obj="itemList" index="0" interface="NodeList"/> |
| <createTextNode var="newTextNode" obj="doc" data='"New Text"'/> |
| <appendChild obj="elementName" var="appendedChild" newChild="newTextNode"/> |
| <firstChild var="textNode" obj="elementName" interface="Node"/> |
| <wholeText obj="textNode" var="wholeText"/> |
| <assertEquals expected='"Margaret MartinNew Text"' actual="wholeText" id="textwholetext02" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/textwholetext03.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="textwholetext03"> |
| <metadata> |
| <title>textwholetext03</title> |
| <creator>IBM</creator> |
| <description> |
| Invoke wholetext on two newly created text nodes and verify if the value returned |
| is correct. |
| </description> |
| <contributor>Neil Delima</contributor> |
| <date qualifier="created">2002-05-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Text3-wholeText"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="text1" type="Text"/> |
| <var name="text2" type="Text"/> |
| <var name="appendedChild" type="Node"/> |
| <var name="combinedText" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <createElementNS var="elem" obj="doc" namespaceURI='"http://www.w3.org/1999/xhtml"' qualifiedName='"p"'/> |
| <createTextNode var="text1" obj="doc" data='"Text I"'/> |
| <createTextNode var="text2" obj="doc" data='" Text II"'/> |
| <appendChild obj="elem" var="appendedChild" newChild="text1"/> |
| <appendChild obj="elem" var="appendedChild" newChild="text2"/> |
| <wholeText obj="text1" var="combinedText"/> |
| <assertEquals expected='"Text I Text II"' actual="combinedText" id="textwholetext03" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfogettypename03.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfogettypename03"> |
| <metadata> |
| <title>typeinfogettypename03</title> |
| <creator>IBM</creator> |
| <description> |
| The typeName attribute states the name of a type declared for the associated element or |
| attribute, or null if unknown. |
| Invoke getSchemaTypeInfo method on an attribute having [type definition] property. Expose |
| {name} and {target namespace} properties of the [type definition] property. |
| Verify that the typeName of id's schemaTypeInfo are correct. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="attrid" type="Attr"/> |
| <var name="acElem" type="Element"/> |
| <var name="attrTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attrid" obj="acElem" name='"id"'/> |
| <schemaTypeInfo var="attrTypeInfo" obj="attrid" interface="Attr"/> |
| <typeName var="typeName" obj="attrTypeInfo"/> |
| <assertEquals expected='"ID"' actual="typeName" id="typeinfogettypename03_1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfogettypename04.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfogettypename04"> |
| <metadata> |
| <title>typeinfogettypename04</title> |
| <creator>IBM</creator> |
| <description> |
| The typeName attribute states the name of a type declared for the associated element or |
| attribute, or null if unknown. |
| Invoke getSchemaTypeInfo method on an attribute having [member type definition]property. Expose |
| {name} and {target namespace} properties of the [member type definition] property. |
| Verify that the typeName of an em element's schemaTypeInfo is correct. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="emElem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="emElem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="emElem" interface="Element"/> |
| <typeName var="typeName" obj="elemTypeInfo"/> |
| <assertEquals expected='"emType"' actual="typeName" id="typeinfogettypename04_1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfogettypenamespace01.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfogettypenamespace01"> |
| <metadata> |
| <title>typeinfogettypenamespace01</title> |
| <creator>IBM</creator> |
| <description> |
| The typeNamespace attribute states the namespace of a type declared for the associated element or |
| attribute, or null if unknown. |
| Invoke getSchemaTypeInfo method on an attribute having [type definition] property. Expose |
| {name} and {target namespace} properties of the [type definition] property. |
| Verify that the typeNamespace of the attrib1 and attrib3's schemaTypeInfo are correct. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeNamespace"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acElem" type="Element"/> |
| <var name="titleAttr" type="Attr"/> |
| <var name="attrTypeInfo" type="TypeInfo"/> |
| <var name="typeNamespace" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="titleAttr" obj="acElem" name='"title"'/> |
| <schemaTypeInfo var="attrTypeInfo" obj="titleAttr" interface="Attr"/> |
| <typeNamespace var="typeNamespace" obj="attrTypeInfo"/> |
| <assertEquals expected='"http://www.w3.org/2001/XMLSchema"' actual="typeNamespace" id="typeinfogettypename01_1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfogettypenamespace03.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfogettypenamespace03"> |
| <metadata> |
| <title>typeinfogettypenamespace03</title> |
| <creator>IBM</creator> |
| <description> |
| The typeNamespace attribute states the namespace of a type declared for the associated element or |
| attribute, or null if unknown. |
| Invoke getSchemaTypeInfo method on an attribute having [type definition] property. Expose |
| {name} and {target namespace} properties of the [type definition] property. |
| Verify that the typeName of class's schemaTypeInfo is correct. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="classAttr" type="Attr"/> |
| <var name="attrTypeInfo" type="TypeInfo"/> |
| <var name="typeNamespace" type="DOMString"/> |
| <var name="acElem" type="Element"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acElem" obj="elemList" index="1" interface="NodeList"/> |
| <getAttributeNode var="classAttr" obj="acElem" name='"class"'/> |
| <schemaTypeInfo var="attrTypeInfo" obj="classAttr" interface="Attr"/> |
| <typeNamespace var="typeNamespace" obj="attrTypeInfo"/> |
| <assertEquals expected='"http://www.w3.org/1999/xhtml"' actual="typeNamespace" id="typeinfogettypename03_1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfogettypenamespace04.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfogettypenamespace04"> |
| <metadata> |
| <title>typeinfogettypenamespace04</title> |
| <creator>IBM</creator> |
| <description> |
| The typeName attribute states the name of a type declared for the associated element or |
| attribute, or null if unknown. |
| Invoke getSchemaTypeInfo method on an attribute having [member type definition]property. Expose |
| {name} and {target namespace} properties of the [member type definition] property. |
| Verify that the typeNamespace of eldblUnionA's schemaTypeInfo is null??? (sv) |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-typeName"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="emElem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeNamespace" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="emElem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="emElem" interface="Element"/> |
| <typeNamespace var="typeNamespace" obj="elemTypeInfo"/> |
| <assertEquals expected='"http://www.w3.org/1999/xhtml"' actual="typeNamespace" id="typeinfogettypenamespace04_1" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom01.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom01"> |
| <metadata> |
| <title>typeinfoisderivedfrom01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DTD types always return false for isDerivedFrom. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"title"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/TR/REC-xml"' |
| typeNameArg='"CDATA"' derivationMethod="0"/> |
| <assertFalse actual="isDerived" id="isDerived0"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/TR/REC-xml"' |
| typeNameArg='"CDATA"' derivationMethod="15"/> |
| <assertFalse actual="isDerived" id="isDerived15"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom02.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom02"> |
| <metadata> |
| <title>typeinfoisderivedfrom02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check how xsd:string is derived from itself. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"title"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xsd:string --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"string"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="derivedFromSelfRestriction"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"string"' derivationMethod="14"/> |
| <assertFalse actual="isDerived" id="derivedFromSelfOther"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"string"' derivationMethod="0"/> |
| <assertTrue actual="isDerived" id="derivedFromSelfAny"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"string"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromSelfAll"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom03.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom03"> |
| <metadata> |
| <title>typeinfoisderivedfrom03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check that isDerivedFrom does considers xsd:string to be derived from anySimpleType. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"title"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xsd:string --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"string"' ignoreCase="false" id="nameIsString"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromAnySimpleType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom04.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom04"> |
| <metadata> |
| <title>typeinfoisderivedfrom04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if xsd:string is derived from xsd:anyType by any method. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"title"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xsd:string --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"string"' ignoreCase="false" id="nameIsString"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom05.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom05"> |
| <metadata> |
| <title>typeinfoisderivedfrom05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if xsd:string is derived from xsd:anyType by restriction. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"title"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xsd:string --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"string"' ignoreCase="false" id="nameIsString"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyTypeRestrictionOnly"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom06.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom06"> |
| <metadata> |
| <title>typeinfoisderivedfrom06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if xsd:string is derived from xsd:anyType by any method except restriction. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"title"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xsd:string --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"string"' ignoreCase="false" id="nameIsString"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="14"/> |
| <assertFalse actual="isDerived" id="derivedFromAnyTypeExceptRestriction"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom07.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom07"> |
| <metadata> |
| <title>typeinfoisderivedfrom07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if xsd:string is derived from xsd:anyType using 0 as derivation method. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"title"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xsd:string --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"string"' ignoreCase="false" id="nameIsString"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="0"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyType0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom08.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom08"> |
| <metadata> |
| <title>typeinfoisderivedfrom08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if classType is derived from xsd:string by any method. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"class"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xhtml:classType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"classType"' ignoreCase="false" id="nameIsString"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"string"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromString"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom09.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom09"> |
| <metadata> |
| <title>typeinfoisderivedfrom09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if classType is derived from xsd:anySimpleType by any method. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"class"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xhtml:classType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"classType"' ignoreCase="false" id="nameIsString"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromAnySimpleType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom10.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom10"> |
| <metadata> |
| <title>typeinfoisderivedfrom10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if classType is derived from anyType by any method. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"class"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xhtml:classType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"classType"' ignoreCase="false" id="nameIsString"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom11.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom11"> |
| <metadata> |
| <title>typeinfoisderivedfrom11</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if classType is derived from xsd:anyType by restriction. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"class"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xhtml:classType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"classType"' ignoreCase="false" id="nameIsString"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyTypeRestrictionOnly"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom12.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom12"> |
| <metadata> |
| <title>typeinfoisderivedfrom12</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check classType is derived from anyType specifying derivationMethod as 0. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"class"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xhtml:classType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"classType"' ignoreCase="false" id="nameIsString"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="0"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyType0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom13.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom13"> |
| <metadata> |
| <title>typeinfoisderivedfrom13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if classType is derived from xsd:anyType by any method other than restriction. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"class"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xhtml:classType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"classType"' ignoreCase="false" id="name"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="14"/> |
| <assertFalse actual="isDerived" id="derivedFromAnyTypeExceptRestriction"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom14.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom14"> |
| <metadata> |
| <title>typeinfoisderivedfrom14</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check how classType is derived from itself. |
| </description> |
| <date qualifier="created">2004-01-11</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="acronymElem" name='"class"'/> |
| <schemaTypeInfo var="typeInfo" obj="attr" interface="Attr"/> |
| <!-- type info should be xhtml:classType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"classType"' ignoreCase="false" id="name"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"classType"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="derivedFromSelfRestriction"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"classType"' derivationMethod="14"/> |
| <assertFalse actual="isDerived" id="notDerivedFromSelfOther"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"classType"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromSelfAll"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"classType"' derivationMethod="0"/> |
| <assertTrue actual="isDerived" id="derivedFromSelfAny"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom15.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom15"> |
| <metadata> |
| <title>typeinfoisderivedfrom15</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check "emType" is derived from emp0001_3Type by any method. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be emType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"emType"' ignoreCase="false" id="name"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"emp0001_3Type"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromEmp13AnyMethod"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom16.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom16"> |
| <metadata> |
| <title>typeinfoisderivedfrom16</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check emType is derived from emp0001_3Type by union. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be emType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"emType"' ignoreCase="false" id="name"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"emp0001_3Type"' derivationMethod="4"/> |
| <assertTrue actual="isDerived" id="derivedFromEmp13Union"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom17.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom17"> |
| <metadata> |
| <title>typeinfoisderivedfrom17</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if emType is derived from emp0001_3Type by any method other than union. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be emType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"emType"' ignoreCase="false" id="name"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"emp0001_3Type"' derivationMethod="11"/> |
| <assertFalse actual="isDerived" id="derivedFromEmp13NotUnion"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom18.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom18"> |
| <metadata> |
| <title>typeinfoisderivedfrom18</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if emType is derived from xsd:ID by restriction. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be emType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"emType"' ignoreCase="false" id="typeName"/> |
| <!-- emType is not derived by restriction from xsd:ID even though |
| every memberType in the union is derived by restriction from xsd:ID --> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"ID"' derivationMethod="1"/> |
| <assertFalse actual="isDerived" id="derivedFromID"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom19.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom19"> |
| <metadata> |
| <title>typeinfoisderivedfrom19</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check emType is derived from anySimpleType by restriction. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be emType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"emType"' ignoreCase="false" id="typeName"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="derivedFromAnySimpleType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom20.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom20"> |
| <metadata> |
| <title>typeinfoisderivedfrom20</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if emType is derived from anyType by restriction. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be emType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom21.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom21"> |
| <metadata> |
| <title>typeinfoisderivedfrom21</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if emType is derived from itself. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be emType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"emType"' ignoreCase="false" id="typeName"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"emType"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="derivedFromSelfByRestriction"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"emType"' derivationMethod="14"/> |
| <assertFalse actual="isDerived" id="notDerivedFromSelfOtherMethod"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"emType"' derivationMethod="0"/> |
| <assertTrue actual="isDerived" id="derivedFromSelfByAny"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"emType"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromSelfByAll"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom22.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom22"> |
| <metadata> |
| <title>typeinfoisderivedfrom22</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check strongType is derived from xsd:string by any method. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be strongType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"strongType"' ignoreCase="false" id="typeName"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"string"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromStringAnyMethod"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom23.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom23"> |
| <metadata> |
| <title>typeinfoisderivedfrom23</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if strongType is derived from xsd:string by list. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be strongType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"strongType"' ignoreCase="false" id="typeName"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"string"' derivationMethod="8"/> |
| <assertTrue actual="isDerived" id="derivedFromStringList"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom24.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom24"> |
| <metadata> |
| <title>typeinfoisderivedfrom24</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if strongType is derived from xsd:string by any method other than list. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be strongType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"strongType"' ignoreCase="false" id="typeName"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"string"' derivationMethod="7"/> |
| <assertFalse actual="isDerived" id="derivedFromStringNotList"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom25.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom25"> |
| <metadata> |
| <title>typeinfoisderivedfrom25</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if strongType is derived from anySimpleType by restriction. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be strongType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"strongType"' ignoreCase="false" id="typeName"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="derivedFromAnySimpleType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom26.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom26"> |
| <metadata> |
| <title>typeinfoisderivedfrom26</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if strongType is derived from anyType by restriction. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be strongType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"strongType"' ignoreCase="false" id="typeName"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom27.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom27"> |
| <metadata> |
| <title>typeinfoisderivedfrom27</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if strongType is derived from anyType by union or extension. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be strongType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"strongType"' ignoreCase="false" id="typeName"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="6"/> |
| <assertFalse actual="isDerived" id="derivedFromAnyType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom28.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom28"> |
| <metadata> |
| <title>typeinfoisderivedfrom28</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check how strongType is derived from itself. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be strongType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"strongType"' ignoreCase="false" id="typeName"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"strongType"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="notDerivedFromSelfRestriction"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"strongType"' derivationMethod="14"/> |
| <assertFalse actual="isDerived" id="notDerivedFromSelfOther"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"strongType"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="notDerivedFromSelfAll"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"strongType"' derivationMethod="0"/> |
| <assertTrue actual="isDerived" id="notDerivedFromSelfAny"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom29.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom29"> |
| <metadata> |
| <title>typeinfoisderivedfrom29</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type for p element is derived from pType. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <!-- check its relationship with pType --> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"pType"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromPTypeAnyMethod"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom30.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom30"> |
| <metadata> |
| <title>typeinfoisderivedfrom30</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type for p element is derived from pType by restriction. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"pType"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="derivedFromPTypeRestriction"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom31.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom31"> |
| <metadata> |
| <title>typeinfoisderivedfrom31</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check anonymous type for p element is derived from pType by any method other than restriction. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <!-- check its relationship with pType --> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"pType"' derivationMethod="14"/> |
| <assertFalse actual="isDerived" id="derivedFromPTypeNotRestriction"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom32.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom32"> |
| <metadata> |
| <title>typeinfoisderivedfrom32</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of p element is derived from part1. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <!-- check its relationship with part1 --> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"part1"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromPart1AnyMethod"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom33.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom33"> |
| <metadata> |
| <title>typeinfoisderivedfrom33</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check is anonymous type of p element is derived by extension from part1. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"part1"' derivationMethod="2"/> |
| <assertTrue actual="isDerived" id="derivedFromPart1Extension"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom34.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom34"> |
| <metadata> |
| <title>typeinfoisderivedfrom34</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of p element is derived from part1 by any method other than extension. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"part1"' derivationMethod="13"/> |
| <assertFalse actual="isDerived" id="derivedFromPart1NotExtension"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom35.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom35"> |
| <metadata> |
| <title>typeinfoisderivedfrom35</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of p element is derived from xsd:simpleType. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <!-- check relationship with anySimpleType --> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="15"/> |
| <assertFalse actual="isDerived" id="derivedFromAnySimpleType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom36.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom36"> |
| <metadata> |
| <title>typeinfoisderivedfrom36</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of p element is derived from xsd:anyType. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <!-- check relationship with anyType --> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="15"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyTypeAnyMethod"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom37.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom37"> |
| <metadata> |
| <title>typeinfoisderivedfrom37</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of p element is derived from xsd:anyType by restriction. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="1"/> |
| <assertFalse actual="isDerived" id="derivedFromAnyTypeRestriction"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom38.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom38"> |
| <metadata> |
| <title>typeinfoisderivedfrom38</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of p element is derived from xsd:anyType by any method other |
| than extension. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="13"/> |
| <assertFalse actual="isDerived" id="derivedFromAnyTypeNotExtension"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom39.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom39"> |
| <metadata> |
| <title>typeinfoisderivedfrom39</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of p element derives from itself. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="typeNS" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be anonymous type defined within p element --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <typeNamespace var="typeNS" obj="typeInfo"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='typeNS' |
| typeNameArg='typeName' derivationMethod="15"/> |
| <assertFalse actual="isDerived" id="notDerivedFromSelf"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom40.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom40"> |
| <metadata> |
| <title>typeinfoisderivedfrom40</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if emType is derived from xsd:ID by union. |
| </description> |
| <date qualifier="created">2004-01-13</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be emType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"emType"' ignoreCase="false" id="typeName"/> |
| <!-- emType is derived by union from xsd:ID since |
| at least one memberType in the union is derived by restriction from xsd:ID --> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"ID"' derivationMethod="4"/> |
| <assertTrue actual="isDerived" id="derivedFromID"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom41.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom41"> |
| <metadata> |
| <title>typeinfoisderivedfrom41</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if emType is derived from xsd:ID by any method other than union or restriction. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be emType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"emType"' ignoreCase="false" id="typeName"/> |
| <!-- emType is derived by union from xsd:ID since |
| at least one memberType in the union is derived by restriction from xsd:ID --> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"ID"' derivationMethod="10"/> |
| <assertFalse actual="isDerived" id="derivedFromID"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom42.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom42"> |
| <metadata> |
| <title>typeinfoisderivedfrom42</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if strongType is derived from anySimpleType by list. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <var name="typeName" type="DOMString"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <!-- type should be strongType --> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <typeName var="typeName" obj="typeInfo"/> |
| <assertEquals actual="typeName" expected='"strongType"' ignoreCase="false" id="typeName"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="8"/> |
| <assertTrue actual="isDerived" id="derivedFromAnySimpleType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom43.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom43"> |
| <metadata> |
| <title>typeinfoisderivedfrom43</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of acronym element derived from anyType by restriction. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="acronymElem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="1"/> |
| <assertFalse actual="isDerived" id="derivedFromAnyType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom44.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom44"> |
| <metadata> |
| <title>typeinfoisderivedfrom44</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of acronym element derived from anyType by any method other than extension. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="acronymElem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="13"/> |
| <assertFalse actual="isDerived" id="derivedFromAnyType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom45.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom45"> |
| <metadata> |
| <title>typeinfoisderivedfrom45</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of acronym element derived from anySimpleType by extension. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="acronymElem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="2"/> |
| <assertTrue actual="isDerived" id="derivedFromAnySimpleType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom46.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom46"> |
| <metadata> |
| <title>typeinfoisderivedfrom46</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of acronym element derived from anySimpleType by any method other than extension. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="acronymElem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="13"/> |
| <assertFalse actual="isDerived" id="derivedFromAnySimpleType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom47.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom47"> |
| <metadata> |
| <title>typeinfoisderivedfrom47</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of acronym element derived from xsd:string by extension. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="acronymElem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"string"' derivationMethod="2"/> |
| <assertTrue actual="isDerived" id="derivedFromString"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom48.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom48"> |
| <metadata> |
| <title>typeinfoisderivedfrom48</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if anonymous type of acronym element derived from xsd:string by any method other than extension. |
| </description> |
| <date qualifier="created">2004-01-15</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="2" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="acronymElem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"string"' derivationMethod="13"/> |
| <assertFalse actual="isDerived" id="derivedFromString"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom49.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom49"> |
| <metadata> |
| <title>typeinfoisderivedfrom49</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a list of a item type returns true |
| when asked if it derives by list from the item type. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"double"' derivationMethod="8"/> |
| <assertTrue actual="isDerived" id="derivedFromDoubleList"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom50.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom50"> |
| <metadata> |
| <title>typeinfoisderivedfrom50</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a list of a item type returns true |
| when asked if it derives by any method from the item type. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"double"' derivationMethod="0"/> |
| <assertTrue actual="isDerived" id="derivedFromDoubleAny"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom51.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom51"> |
| <metadata> |
| <title>typeinfoisderivedfrom51</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a list of a item type returns false |
| when asked if it derives by any method other than list from the item type. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"double"' derivationMethod="7"/> |
| <assertFalse actual="isDerived" id="derivedFromDoubleNonList"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom52.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom52"> |
| <metadata> |
| <title>typeinfoisderivedfrom52</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a list of a item type returns false |
| when asked if it derives by restriction from anySimpleType type. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="1"/> |
| <assertFalse actual="isDerived" id="derivedFromAnySimpleRestriction"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom53.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom53"> |
| <metadata> |
| <title>typeinfoisderivedfrom53</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a list of a item type returns true |
| when asked if it derives by extension from anySimpleType. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="2"/> |
| <assertTrue actual="isDerived" id="derivedFromAnySimpleExtension"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom54.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom54"> |
| <metadata> |
| <title>typeinfoisderivedfrom54</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a list of a item type returns true |
| when asked if it derives by list from anySimpleType. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anySimpleType"' derivationMethod="8"/> |
| <assertTrue actual="isDerived" id="derivedFromAnySimpleList"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom55.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom55"> |
| <metadata> |
| <title>typeinfoisderivedfrom55</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a list of a item type returns true |
| when asked if it derives by extension from anyType type. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="2"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyRestriction"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom56.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom56"> |
| <metadata> |
| <title>typeinfoisderivedfrom56</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a list of a item type returns true |
| when asked if it derives by extension from anyType. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="2"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyExtension"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom57.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom57"> |
| <metadata> |
| <title>typeinfoisderivedfrom57</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a list of a item type returns true |
| when asked if it derives by list from anyType. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"anyType"' derivationMethod="8"/> |
| <assertTrue actual="isDerived" id="derivedFromAnyList"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom58.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom58"> |
| <metadata> |
| <title>typeinfoisderivedfrom58</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a union returns true |
| when asked if it derives by union from a member type of the union. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="codeElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"code"' interface="Document"/> |
| <item var="codeElem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="codeElem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' |
| typeNameArg='"unbounded"' derivationMethod="4"/> |
| <assertTrue actual="isDerived" id="isDerived"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom59.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom59"> |
| <metadata> |
| <title>typeinfoisderivedfrom59</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if a type derived by extension from a union returns true |
| when asked if it derives by union from a restricted base of |
| a member of type union. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="codeElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="elem" type="Element"/> |
| <var name="elemName" type="DOMString"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"code"' interface="Document"/> |
| <item var="codeElem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="codeElem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"integer"' derivationMethod="4"/> |
| <assertTrue actual="isDerived" id="isDerived"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom60.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom60"> |
| <metadata> |
| <title>typeinfoisderivedfrom60</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if xs:IDREFS is derived by list from xs:IDREF. |
| </description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"IDREF"' derivationMethod="8"/> |
| <assertTrue actual="isDerived" id="isDerived"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom61.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom61"> |
| <metadata> |
| <title>typeinfoisderivedfrom61</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if xs:byte is derived by restriction from xs:short</description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"short"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="isDerived"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom62.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom62"> |
| <metadata> |
| <title>typeinfoisderivedfrom62</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check if xs:byte is derived by restriction from xs:decimal</description> |
| <date qualifier="created">2004-02-14</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="typeInfo" type="TypeInfo"/> |
| <var name="isDerived" type="boolean"/> |
| <load var="doc" href="typeinfo" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="typeInfo" obj="elem" interface="Element"/> |
| <assertNotNull actual="typeInfo" id="typeInfoNotNull"/> |
| <isDerivedFrom var="isDerived" obj="typeInfo" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' |
| typeNameArg='"decimal"' derivationMethod="1"/> |
| <assertTrue actual="isDerived" id="isDerived"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom63.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom63"> |
| <metadata> |
| <title>typeinfoisderivedfrom63</title> |
| <creator>IBM</creator> |
| <description> |
| The isDerivedFrom method checks if this TypeInfo derives from the specified ancestor type. |
| If the document's schema is a DTD or no schema is associated with the document, this method |
| will always return false. |
| Get schemaTypeInfo on an element that belongs to a document with an XML DTD. Invoke method |
| isDerivedFrom and verify that returned the typeNamespace is null. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-10</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acronymElem" type="Element"/> |
| <var name="retValue" type="boolean"/> |
| <var name="typeNamespace" type="DOMString"/> |
| <var name="nullName" type="DOMString" isNull="true"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acronymElem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="acronymElem" interface="Element"/> |
| <isDerivedFrom obj="elemTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/TR/REC-xml"' typeNameArg="nullName" derivationMethod="0" /> |
| <assertFalse actual="retValue" id="typeinfoisderivedfrom63" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom64.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom64"> |
| <metadata> |
| <title>typeinfoisderivedfrom64</title> |
| <creator>IBM</creator> |
| <description> |
| Check that the simpleType of an attributes derives by restriction from itself |
| and from its base type. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="acElem" type="Element"/> |
| <var name="classAttr" type="Attr"/> |
| <var name="attrTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="retValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="acElem" obj="elemList" index="1" interface="NodeList"/> |
| <getAttributeNode var="classAttr" obj="acElem" name='"class"'/> |
| <schemaTypeInfo var="attrTypeInfo" obj="classAttr" interface="Attr"/> |
| <isDerivedFrom obj="attrTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' typeNameArg='"classType"' derivationMethod="1"/> |
| <assertTrue actual="retValue" id="derivedFromClassType" /> |
| <isDerivedFrom obj="attrTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' typeNameArg='"string"' derivationMethod="1"/> |
| <assertTrue actual="retValue" id="derivedFromString" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom65.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom65"> |
| <metadata> |
| <title>typeinfoisderivedfrom65</title> |
| <creator>IBM</creator> |
| <description> |
| The isDerivedFrom method checks if this TypeInfo derives from the specified ancestor type. |
| Get schemaTypeInfo on a simple type attribute that belongs to a document with an XML schema. |
| Invoke method isDerivedFrom with derivation method list and verify that the value returned is true. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemTypeInfo" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="strongElem" type="Element"/> |
| <var name="attrTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="retValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="strongElem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="strongElem" interface="Element"/> |
| <isDerivedFrom obj="elemTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' typeNameArg='"string"' derivationMethod="8"/> |
| <assertTrue actual="retValue" id="lisrDerivedFromString" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom66.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom66"> |
| <metadata> |
| <title>typeinfoisderivedfrom66</title> |
| <creator>IBM</creator> |
| <description> |
| The isDerivedFrom method checks if this TypeInfo derives from the specified ancestor type. |
| Get schemaTypeInfo on an element of type Union that belongs to a document with an XML schema. |
| Invoke method isDerivedFrom with derivation method union and verify that the value returned is true. |
| Verify that emType is derived from emp0004_5Type by union. |
| </description> |
| <contributor>Jenny Hsu</contributor> |
| <date qualifier="created">2003-10-28</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="unionElem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="retValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"em"' interface="Document"/> |
| <item var="unionElem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="unionElem" interface="Element"/> |
| <isDerivedFrom obj="elemTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' typeNameArg='"emp0004_5Type"' derivationMethod="0"/> |
| <assertTrue actual="retValue" id="typeinfoisderivedfrom66" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom67.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom67"> |
| <metadata> |
| <title>typeinfoisderivedfrom67</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that isDerivedFrom(...,METHOD_UNION) returns true when there |
| are multiple union derivation steps between the target and |
| ancestor type. |
| </description> |
| <date qualifier="created">2004-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="retValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"sup"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="elem" interface="Element"/> |
| <isDerivedFrom obj="elemTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' typeNameArg='"emp0004_5Type"' derivationMethod="4"/> |
| <assertTrue actual="retValue" id="isDerived" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom68.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom68"> |
| <metadata> |
| <title>typeinfoisderivedfrom68</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that isDerivedFrom(...,0) returns true when there |
| is more than one union derivation steps between the target and |
| ancestor type. |
| </description> |
| <date qualifier="created">2004-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="retValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"sup"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="elem" interface="Element"/> |
| <isDerivedFrom obj="elemTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' typeNameArg='"emp0004_5Type"' derivationMethod="0"/> |
| <assertTrue actual="retValue" id="isDerived" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom69.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom69"> |
| <metadata> |
| <title>typeinfoisderivedfrom69</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that isDerivedFrom(...,DERIVATION_UNION|DERIVATION_LIST) returns false when there |
| is both a union and list derivation steps between the target and |
| ancestor type. |
| </description> |
| <date qualifier="created">2004-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="retValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"sup"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="elem" interface="Element"/> |
| <isDerivedFrom obj="elemTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' typeNameArg='"integer"' derivationMethod="12"/> |
| <assertFalse actual="retValue" id="isDerived" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom70.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom70"> |
| <metadata> |
| <title>typeinfoisderivedfrom70</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that isDerivedFrom(...,0) returns true when there |
| is both a union and list derivation steps between the target and |
| ancestor type. |
| </description> |
| <date qualifier="created">2004-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="retValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"sup"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="elem" interface="Element"/> |
| <isDerivedFrom obj="elemTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/2001/XMLSchema"' typeNameArg='"string"' derivationMethod="0"/> |
| <assertTrue actual="retValue" id="isDerived" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom71.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom71"> |
| <metadata> |
| <title>typeinfoisderivedfrom71</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that isDerivedFrom(...,0) returns true when target type is a list |
| of an union of the ancestor type. |
| </description> |
| <date qualifier="created">2004-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="retValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"code"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="elem" interface="Element"/> |
| <isDerivedFrom obj="elemTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' typeNameArg='"field"' derivationMethod="0"/> |
| <assertTrue actual="retValue" id="isDerived" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom72.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom72"> |
| <metadata> |
| <title>typeinfoisderivedfrom72</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that isDerivedFrom(...,DERIVATION_LIST|DERIVATION_UNION) returns false when target type is a list |
| of an union. |
| ancestor type. |
| </description> |
| <date qualifier="created">2004-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="retValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"code"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="elem" interface="Element"/> |
| <isDerivedFrom obj="elemTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' typeNameArg='"field"' derivationMethod="12"/> |
| <assertFalse actual="retValue" id="isDerived" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/typeinfoisderivedfrom73.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="typeinfoisderivedfrom73"> |
| <metadata> |
| <title>typeinfoisderivedfrom73</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Checks that isDerivedFrom(...,0) returns true where the target type is a union |
| where the ancestor type is a member of the union and is a union itself. |
| </description> |
| <date qualifier="created">2004-03-04</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#TypeInfo-isDerivedFrom"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <implementationAttribute name="validating" value="true"/> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="elemTypeInfo" type="TypeInfo"/> |
| <var name="typeName" type="DOMString"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="retValue" type="boolean"/> |
| <load var="doc" href="hc_staff" willBeModified="false"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"sup"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <schemaTypeInfo var="elemTypeInfo" obj="elem" interface="Element"/> |
| <isDerivedFrom obj="elemTypeInfo" var="retValue" typeNamespaceArg='"http://www.w3.org/1999/xhtml"' typeNameArg='"emType"' derivationMethod="0"/> |
| <assertTrue actual="retValue" id="isDerived" /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/userdatahandler01.xml |
|---|
| 0,0 → 1,87 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="userdatahandler01"> |
| <metadata> |
| <title>userdatahandler01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call setUserData on a node providing a UserDataHandler and rename the node. |
| </description> |
| <date qualifier="created">2004-01-16</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-handleUserDataEvent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="pList" type="NodeList"/> |
| <var name="userDataMonitor" type="UserDataMonitor"/> |
| <var name="oldUserData" type="DOMUserData"/> |
| <var name="elementNS" type="DOMString"/> |
| <var name="newNode" type="Node"/> |
| <var name="notifications" type="List"/> |
| <var name="notification" type="UserDataNotification"/> |
| <var name="operation" type="short"/> |
| <var name="key" type="DOMString"/> |
| <var name="data" type="DOMString"/> |
| <var name="src" type="Node"/> |
| <var name="dst" type="Node"/> |
| <var name="greetingCount" type="int" value="0"/> |
| <var name="salutationCount" type="int" value="0"/> |
| <var name="hello" type="DOMString" value='"Hello"'/> |
| <var name="mister" type="DOMString" value='"Mr."'/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="node" obj="pList" index="0" interface="NodeList"/> |
| <setUserData var="oldUserData" obj="node" key='"greeting"' data='hello' handler="userDataMonitor"/> |
| <setUserData var="oldUserData" obj="node" key='"salutation"' data='mister' handler="userDataMonitor"/> |
| <namespaceURI var="elementNS" obj="node" interface="Node"/> |
| <renameNode var="newNode" obj="doc" n="node" namespaceURI="elementNS" qualifiedName='"div"'/> |
| <allNotifications var="notifications" obj="userDataMonitor"/> |
| <assertSize size="2" collection="notifications" id="twoNotifications"/> |
| <for-each member="notification" collection="notifications"> |
| <operation var="operation" obj="notification"/> |
| <assertEquals actual="operation" expected="4" ignoreCase="false" id="operationIsRename"/> |
| <key var="key" obj="notification"/> |
| <data var="data" obj="notification" interface="UserDataNotification"/> |
| <if> |
| <equals actual="key" expected='"greeting"' ignoreCase="false"/> |
| <assertEquals actual="data" expected='hello' ignoreCase="false" id="greetingDataHello"/> |
| <increment var="greetingCount" value="1"/> |
| <else> |
| <assertEquals actual="key" expected='"salutation"' ignoreCase="false" id="saluationKey"/> |
| <assertEquals actual="data" expected='mister' ignoreCase="false" id="salutationDataMr"/> |
| <increment var="salutationCount" value="1"/> |
| </else> |
| </if> |
| <src interface="UserDataNotification" var="src" obj="notification"/> |
| <assertSame actual="src" expected="node" id="srcIsNode"/> |
| <dst var="dst" obj="notification"/> |
| <if> |
| <!-- will be null if no node needs to be newly created --> |
| <isNull obj="dst"/> |
| <assertSame actual="newNode" expected="node" id="ifDstNullRenameMustReuseNode"/> |
| <else> |
| <!-- otherwise will be same as newNode --> |
| <assertSame actual="dst" expected="newNode" id="dstIsNewNode"/> |
| </else> |
| </if> |
| </for-each> |
| <assertEquals actual="greetingCount" expected="1" ignoreCase="false" id="greetingCountIs1"/> |
| <assertEquals actual="salutationCount" expected="1" ignoreCase="false" id="salutationCountIs1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/userdatahandler02.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="userdatahandler02"> |
| <metadata> |
| <title>userdatahandler02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call setUserData on a node providing a UserDataHandler and clone the node. |
| </description> |
| <date qualifier="created">2004-01-16</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-handleUserDataEvent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="pList" type="NodeList"/> |
| <var name="userDataMonitor" type="UserDataMonitor"/> |
| <var name="oldUserData" type="DOMUserData"/> |
| <var name="elementNS" type="DOMString"/> |
| <var name="newNode" type="Node"/> |
| <var name="notifications" type="List"/> |
| <var name="notification" type="UserDataNotification"/> |
| <var name="operation" type="short"/> |
| <var name="key" type="DOMString"/> |
| <var name="data" type="DOMString"/> |
| <var name="src" type="Node"/> |
| <var name="dst" type="Node"/> |
| <var name="greetingCount" type="int" value="0"/> |
| <var name="salutationCount" type="int" value="0"/> |
| <var name="hello" type="DOMString" value='"Hello"'/> |
| <var name="mister" type="DOMString" value='"Mr."'/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="node" obj="pList" index="0" interface="NodeList"/> |
| <setUserData var="oldUserData" obj="node" key='"greeting"' data='hello' handler="userDataMonitor"/> |
| <setUserData var="oldUserData" obj="node" key='"salutation"' data='mister' handler="userDataMonitor"/> |
| <namespaceURI var="elementNS" obj="node" interface="Node"/> |
| <cloneNode var="newNode" obj="node" deep="true"/> |
| <allNotifications var="notifications" obj="userDataMonitor"/> |
| <assertSize size="2" collection="notifications" id="twoNotifications"/> |
| <for-each member="notification" collection="notifications"> |
| <operation var="operation" obj="notification"/> |
| <assertEquals actual="operation" expected="1" ignoreCase="false" id="operationIsClone"/> |
| <key var="key" obj="notification"/> |
| <data var="data" obj="notification" interface="UserDataNotification"/> |
| <if> |
| <equals actual="key" expected='"greeting"' ignoreCase="false"/> |
| <assertEquals actual="data" expected='hello' ignoreCase="false" id="greetingDataHello"/> |
| <increment var="greetingCount" value="1"/> |
| <else> |
| <assertEquals actual="key" expected='"salutation"' ignoreCase="false" id="saluationKey"/> |
| <assertEquals actual="data" expected='mister' ignoreCase="false" id="salutationDataMr"/> |
| <increment var="salutationCount" value="1"/> |
| </else> |
| </if> |
| <src interface="UserDataNotification" var="src" obj="notification"/> |
| <assertSame actual="src" expected="node" id="srcIsNode"/> |
| <dst var="dst" obj="notification"/> |
| <assertSame actual="dst" expected="newNode" id="dstIsNewNode"/> |
| </for-each> |
| <assertEquals actual="greetingCount" expected="1" ignoreCase="false" id="greetingCountIs1"/> |
| <assertEquals actual="salutationCount" expected="1" ignoreCase="false" id="salutationCountIs1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/userdatahandler03.xml |
|---|
| 0,0 → 1,89 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="userdatahandler03"> |
| <metadata> |
| <title>userdatahandler03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call setUserData on a node providing a UserDataHandler and import the node. |
| </description> |
| <date qualifier="created">2004-01-16</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-handleUserDataEvent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="pList" type="NodeList"/> |
| <var name="userDataMonitor" type="UserDataMonitor"/> |
| <var name="oldUserData" type="DOMUserData"/> |
| <var name="elementNS" type="DOMString"/> |
| <var name="newNode" type="Node"/> |
| <var name="notifications" type="List"/> |
| <var name="notification" type="UserDataNotification"/> |
| <var name="operation" type="short"/> |
| <var name="key" type="DOMString"/> |
| <var name="data" type="DOMString"/> |
| <var name="src" type="Node"/> |
| <var name="dst" type="Node"/> |
| <var name="greetingCount" type="int" value="0"/> |
| <var name="salutationCount" type="int" value="0"/> |
| <var name="hello" type="DOMString" value='"Hello"'/> |
| <var name="mister" type="DOMString" value='"Mr."'/> |
| <var name="newDoc" type="Document"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <implementation var="domImpl" obj="doc"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <createDocument var="newDoc" obj="domImpl" qualifiedName="rootName" namespaceURI="rootNS" doctype="docType"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="node" obj="pList" index="0" interface="NodeList"/> |
| <setUserData var="oldUserData" obj="node" key='"greeting"' data='hello' handler="userDataMonitor"/> |
| <setUserData var="oldUserData" obj="node" key='"salutation"' data='mister' handler="userDataMonitor"/> |
| <namespaceURI var="elementNS" obj="node" interface="Node"/> |
| <importNode var="newNode" obj="doc" importedNode="node" deep="true"/> |
| <allNotifications var="notifications" obj="userDataMonitor"/> |
| <assertSize size="2" collection="notifications" id="twoNotifications"/> |
| <for-each member="notification" collection="notifications"> |
| <operation var="operation" obj="notification"/> |
| <assertEquals actual="operation" expected="2" ignoreCase="false" id="operationIsImport"/> |
| <key var="key" obj="notification"/> |
| <data var="data" obj="notification" interface="UserDataNotification"/> |
| <if> |
| <equals actual="key" expected='"greeting"' ignoreCase="false"/> |
| <assertEquals actual="data" expected='hello' ignoreCase="false" id="greetingDataHello"/> |
| <increment var="greetingCount" value="1"/> |
| <else> |
| <assertEquals actual="key" expected='"salutation"' ignoreCase="false" id="saluationKey"/> |
| <assertEquals actual="data" expected='mister' ignoreCase="false" id="salutationDataMr"/> |
| <increment var="salutationCount" value="1"/> |
| </else> |
| </if> |
| <src interface="UserDataNotification" var="src" obj="notification"/> |
| <assertSame actual="src" expected="node" id="srcIsNode"/> |
| <dst var="dst" obj="notification"/> |
| <assertSame actual="dst" expected="newNode" id="dstIsNewNode"/> |
| </for-each> |
| <assertEquals actual="greetingCount" expected="1" ignoreCase="false" id="greetingCountIs1"/> |
| <assertEquals actual="salutationCount" expected="1" ignoreCase="false" id="salutationCountIs1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/userdatahandler04.xml |
|---|
| 0,0 → 1,90 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="userdatahandler04"> |
| <metadata> |
| <title>userdatahandler04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Call setUserData on a node providing a UserDataHandler and adopt the node. |
| </description> |
| <date qualifier="created">2004-01-16</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-handleUserDataEvent"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="pList" type="NodeList"/> |
| <var name="userDataMonitor" type="UserDataMonitor"/> |
| <var name="oldUserData" type="DOMUserData"/> |
| <var name="elementNS" type="DOMString"/> |
| <var name="newNode" type="Node"/> |
| <var name="notifications" type="List"/> |
| <var name="notification" type="UserDataNotification"/> |
| <var name="operation" type="short"/> |
| <var name="key" type="DOMString"/> |
| <var name="data" type="DOMString"/> |
| <var name="src" type="Node"/> |
| <var name="dst" type="Node"/> |
| <var name="greetingCount" type="int" value="0"/> |
| <var name="salutationCount" type="int" value="0"/> |
| <var name="hello" type="DOMString" value='"Hello"'/> |
| <var name="mister" type="DOMString" value='"Mr."'/> |
| <var name="newDoc" type="Document"/> |
| <var name="rootName" type="DOMString"/> |
| <var name="rootNS" type="DOMString"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <load var="doc" href="barfoo" willBeModified="true"/> |
| <implementation var="domImpl" obj="doc"/> |
| <documentElement var="docElem" obj="doc"/> |
| <namespaceURI var="rootNS" obj="docElem" interface="Node"/> |
| <tagName var="rootName" obj="docElem"/> |
| <createDocument var="newDoc" obj="domImpl" qualifiedName="rootName" namespaceURI="rootNS" doctype="docType"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="node" obj="pList" index="0" interface="NodeList"/> |
| <setUserData var="oldUserData" obj="node" key='"greeting"' data='hello' handler="userDataMonitor"/> |
| <setUserData var="oldUserData" obj="node" key='"salutation"' data='mister' handler="userDataMonitor"/> |
| <namespaceURI var="elementNS" obj="node" interface="Node"/> |
| <adoptNode var="newNode" obj="doc" source="node"/> |
| <allNotifications var="notifications" obj="userDataMonitor"/> |
| <assertSize size="2" collection="notifications" id="twoNotifications"/> |
| <for-each member="notification" collection="notifications"> |
| <operation var="operation" obj="notification"/> |
| <assertEquals actual="operation" expected="5" ignoreCase="false" id="operationIsImport"/> |
| <key var="key" obj="notification"/> |
| <data var="data" obj="notification" interface="UserDataNotification"/> |
| <if> |
| <equals actual="key" expected='"greeting"' ignoreCase="false"/> |
| <assertEquals actual="data" expected='hello' ignoreCase="false" id="greetingDataHello"/> |
| <increment var="greetingCount" value="1"/> |
| <else> |
| <assertEquals actual="key" expected='"salutation"' ignoreCase="false" id="saluationKey"/> |
| <assertEquals actual="data" expected='mister' ignoreCase="false" id="salutationDataMr"/> |
| <increment var="salutationCount" value="1"/> |
| </else> |
| </if> |
| <src interface="UserDataNotification" var="src" obj="notification"/> |
| <assertSame actual="src" expected="node" id="srcIsNode"/> |
| <dst var="dst" obj="notification"/> |
| <!-- spec says dst must be newly created --> |
| <assertNull actual="dst" id="dstIsNull"/> |
| </for-each> |
| <assertEquals actual="greetingCount" expected="1" ignoreCase="false" id="greetingCountIs1"/> |
| <assertEquals actual="salutationCount" expected="1" ignoreCase="false" id="salutationCountIs1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/wellformed01.xml |
|---|
| 0,0 → 1,88 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="wellformed01"> |
| <metadata> |
| <title>wellformed01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a document with an XML 1.1 valid but XML 1.0 invalid element and |
| normalize document with well-formed set to true. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-well-formed"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullString" type="DOMString" isNull="true"/> |
| <var name="nullDoctype" type="DocumentType" isNull="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="retval" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="locator" type="DOMLocator"/> |
| <var name="relatedNode" type="Node"/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" |
| namespaceURI="nullString" |
| qualifiedName="nullString" |
| doctype="nullDoctype"/> |
| <assertDOMException id="xml10InvalidName"> |
| <INVALID_CHARACTER_ERR> |
| <createElementNS var="elem" obj="doc" |
| namespaceURI='"http://www.example.org/domts/wellformed01"' |
| qualifiedName='"LegalNameࢎ"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| <try> |
| <xmlVersion obj="doc" value='"1.1"' interface="Document"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <createElementNS var="elem" obj="doc" |
| namespaceURI='"http://www.example.org/domts/wellformed01"' |
| qualifiedName='"LegalNameࢎ"'/> |
| <appendChild var="retval" obj="doc" newChild="elem"/> |
| <xmlVersion obj="doc" value='"1.0"' interface="Document"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <setParameter obj="domConfig" name='"well-formed"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <assertEquals actual="severity" expected="2" ignoreCase="false" id="severity"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <assertEquals actual="type" expected='"wf-invalid-character-in-node-name"' |
| ignoreCase="false" id="type"/> |
| <location var="locator" obj="error" interface="DOMError"/> |
| <relatedNode var="relatedNode" obj="locator" interface="DOMLocator"/> |
| <assertSame actual="relatedNode" expected="elem" id="relatedNode"/> |
| </for-each> |
| <assertSize size="1" collection="errors" id="oneError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/wellformed02.xml |
|---|
| 0,0 → 1,77 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="wellformed02"> |
| <metadata> |
| <title>wellformed02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a document with an XML 1.1 valid but XML 1.0 invalid element and |
| normalize document with well-formed set to false. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-well-formed"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullString" type="DOMString" isNull="true"/> |
| <var name="nullDoctype" type="DocumentType" isNull="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="retval" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" |
| namespaceURI="nullString" |
| qualifiedName="nullString" |
| doctype="nullDoctype"/> |
| <assertDOMException id="xml10InvalidName"> |
| <INVALID_CHARACTER_ERR> |
| <createElementNS var="elem" obj="doc" |
| namespaceURI='"http://www.example.org/domts/wellformed02"' |
| qualifiedName='"LegalNameࢎ"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| <try> |
| <xmlVersion obj="doc" value='"1.1"' interface="Document"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <createElementNS var="elem" obj="doc" |
| namespaceURI='"http://www.example.org/domts/wellformed02"' |
| qualifiedName='"LegalNameࢎ"'/> |
| <appendChild var="retval" obj="doc" newChild="elem"/> |
| <xmlVersion obj="doc" value='"1.0"' interface="Document"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"well-formed"' value="false"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"well-formed"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <assertSize size="0" collection="errors" id="noError"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/wellformed03.xml |
|---|
| 0,0 → 1,86 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="wellformed03"> |
| <metadata> |
| <title>wellformed03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a document with an XML 1.1 valid but XML 1.0 invalid attribute and |
| normalize document with well-formed set to true. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-well-formed"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDoctype" type="DocumentType" isNull="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="retval" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="locator" type="DOMLocator"/> |
| <var name="relatedNode" type="Node"/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| qualifiedName='"html"' |
| doctype="nullDoctype"/> |
| <documentElement var="docElem" obj="doc"/> |
| <assertDOMException id="xml10InvalidName"> |
| <INVALID_CHARACTER_ERR> |
| <createAttribute var="attr" obj="doc" |
| name='"LegalNameࢎ"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| <try> |
| <xmlVersion obj="doc" value='"1.1"' interface="Document"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <setAttribute obj="docElem" name='"LegalNameࢎ"' value='"foo"'/> |
| <getAttributeNode var="attr" obj="docElem" name='"LegalNameࢎ"'/> |
| <xmlVersion obj="doc" value='"1.0"' interface="Document"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <setParameter obj="domConfig" name='"well-formed"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <assertEquals actual="severity" expected="2" ignoreCase="false" id="severity"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <assertEquals actual="type" expected='"wf-invalid-character-in-node-name"' |
| ignoreCase="false" id="type"/> |
| <location var="locator" obj="error" interface="DOMError"/> |
| <relatedNode var="relatedNode" obj="locator" interface="DOMLocator"/> |
| <assertSame actual="relatedNode" expected="attr" id="relatedNode"/> |
| </for-each> |
| <assertSize size="1" collection="errors" id="oneError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/core/wellformed04.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="wellformed04"> |
| <metadata> |
| <title>wellformed04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Create a document with an XML 1.1 valid but XML 1.0 invalid attribute and |
| normalize document with well-formed set to false. |
| </description> |
| <date qualifier="created">2004-02-24</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#Document3-normalizeDocument"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-well-formed"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="nullDoctype" type="DocumentType" isNull="true"/> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="attr" type="Attr"/> |
| <var name="retval" type="Node"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="canSet" type="boolean"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <implementation var="domImpl"/> |
| <createDocument var="doc" obj="domImpl" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| qualifiedName='"html"' |
| doctype="nullDoctype"/> |
| <documentElement var="docElem" obj="doc"/> |
| <assertDOMException id="xml10InvalidName"> |
| <INVALID_CHARACTER_ERR> |
| <createAttributeNS var="attr" obj="doc" |
| namespaceURI="nullNS" |
| qualifiedName='"LegalNameࢎ"'/> |
| </INVALID_CHARACTER_ERR> |
| </assertDOMException> |
| <try> |
| <xmlVersion obj="doc" value='"1.1"' interface="Document"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <setAttributeNS obj="docElem" namespaceURI="nullNS" qualifiedName='"LegalNameࢎ"' value='"foo"'/> |
| <xmlVersion obj="doc" value='"1.0"' interface="Document"/> |
| <domConfig var="domConfig" obj="doc" interface="Document"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"well-formed"' value="false"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"well-formed"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <normalizeDocument obj="doc"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <assertNull actual="error" id="noErrorsExpected"/> |
| </for-each> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/.cvsignore |
|---|
| 0,0 → 1,3 |
| dom3.dtd |
| test-to-html.xsl |
| dom3.xsd |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/CVS/Entries |
|---|
| 0,0 → 1,5 |
| D/files//// |
| /.cvsignore/1.2/Fri Apr 3 02:47:57 2009// |
| /alltests.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /hasFeature01.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /metadata.xml/1.1/Fri Apr 3 02:47:56 2009// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/events |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/CVS/Template |
|---|
| --- test/testcases/tests/level3/events/alltests.xml (nonexistent) |
| +++ test/testcases/tests/level3/events/alltests.xml (revision 4364) |
| @@ -0,0 +1,21 @@ |
| +<?xml version="1.0" encoding="UTF-8"?> |
| +<?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| +<!-- |
| +Copyright (c) 2003-2004 World Wide Web Consortium, |
| +(Massachusetts Institute of Technology, Institut National de |
| +Recherche en Informatique et en Automatique, Keio University). All |
| +Rights Reserved. This program is distributed under the W3C's Software |
| +Intellectual Property License. This program is distributed in the |
| +hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| +PURPOSE. |
| +See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| +--> |
| +<!DOCTYPE suite SYSTEM "dom3.dtd"> |
| +<suite xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="alltests"> |
| +<metadata> |
| +<title>DOM Level 3 Events Test Suite</title> |
| +<creator>DOM Test Suite Project</creator> |
| +</metadata> |
| + <suite.member href="hasFeature01.xml"/> |
| +</suite> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/files/CVS/Entries |
|---|
| 0,0 → 1,3 |
| /staff.dtd/1.1/Fri Apr 3 02:47:56 2009// |
| /staff.xml/1.1/Fri Apr 3 02:47:57 2009// |
| D |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/events/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/files/CVS/Template |
|---|
| --- test/testcases/tests/level3/events/files/staff.dtd (nonexistent) |
| +++ test/testcases/tests/level3/events/files/staff.dtd (revision 4364) |
| @@ -0,0 +1,17 @@ |
| +<!ELEMENT employeeId (#PCDATA)> |
| +<!ELEMENT name (#PCDATA)> |
| +<!ELEMENT position (#PCDATA)> |
| +<!ELEMENT salary (#PCDATA)> |
| +<!ELEMENT address (#PCDATA)> |
| +<!ELEMENT entElement ( #PCDATA ) > |
| +<!ELEMENT gender ( #PCDATA | entElement )* > |
| +<!ELEMENT employee (employeeId, name, position, salary, gender, address) > |
| +<!ELEMENT staff (employee)+> |
| +<!ATTLIST entElement |
| + attr1 CDATA "Attr"> |
| +<!ATTLIST address |
| + domestic CDATA #IMPLIED |
| + street CDATA "Yes"> |
| +<!ATTLIST entElement |
| + domestic CDATA "MALE" > |
| + |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/files/staff.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE staff SYSTEM "staff.dtd" [ |
| <!ENTITY ent1 "es"> |
| <!ENTITY ent2 "1900 Dallas Road"> |
| <!ENTITY ent3 "Texas"> |
| <!ENTITY ent4 "<entElement domestic='Yes'>Element data</entElement><?PItarget PIdata?>"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ENTITY ent1 "This entity should be discarded"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| ]> |
| <!-- This is comment number 1.--> |
| <staff> |
| <employee> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds<![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Yes">&ent2; Dallas, &ent3; |
| 98554</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>&ent4;</gender> |
| <address domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0004</employeeId> |
| <name>Jeny Oconnor</name> |
| <position>Personnel Director</position> |
| <salary>95,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Y&ent1;">27 South Road. Dallas, Texas 98556</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </staff> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/hasFeature01.xml |
|---|
| 0,0 → 1,32 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="hasFeature01"> |
| <metadata> |
| <title>hasFeature01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| DOMImplementation.hasFeature("eVenTs", "3.0") should return true. |
| </description> |
| <date qualifier="created">2003-12-03</date> |
| </metadata> |
| <var name="impl" type="DOMImplementation"/> |
| <var name="state" type="boolean"/> |
| <implementation var="impl"/> |
| <hasFeature var="state" obj="impl" feature='"eVenTs"' version='"3.0"'/> |
| <assertTrue id="hasEvents30" actual="state"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/events/metadata.xml |
|---|
| 0,0 → 1,19 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE metadata SYSTEM "dom3.dtd"> |
| <!-- This file contains additional metadata about DOM L3 Events tests. |
| Allowing additional documentation without modifying the tests themselves. --> |
| <metadata xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3"> |
| </metadata> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/.cvsignore |
|---|
| 0,0 → 1,3 |
| dom3.dtd |
| test-to-html.xsl |
| dom3.xsd |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/CVS/Entries |
|---|
| 0,0 → 1,180 |
| D/files//// |
| /.cvsignore/1.1/Fri Apr 3 02:47:57 2009// |
| /CertifiedText1.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /CharacterStream1.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /DOMBuilderFilterTest0.xml/1.10/Fri Apr 3 02:47:58 2009// |
| /DOMBuilderFilterTest1.xml/1.9/Fri Apr 3 02:47:57 2009// |
| /DOMBuilderFilterTest2.xml/1.9/Fri Apr 3 02:47:57 2009// |
| /DOMBuilderTest0.xml/1.9/Fri Apr 3 02:47:58 2009// |
| /DOMBuilderTest1.xml/1.10/Fri Apr 3 02:47:57 2009// |
| /DOMBuilderTest2.xml/1.10/Fri Apr 3 02:47:58 2009// |
| /DOMBuilderTest3.xml/1.11/Fri Apr 3 02:47:58 2009// |
| /DOMBuilderTest4.xml/1.10/Fri Apr 3 02:47:57 2009// |
| /DOMBuilderTest5.xml/1.12/Fri Apr 3 02:47:57 2009// |
| /DOMBuilderTest6.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /DOMBuilderTest8.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /DOMEntityResolverTest0.xml/1.14/Fri Apr 3 02:47:57 2009// |
| /DOMEntityResolverTest1.xml/1.13/Fri Apr 3 02:47:57 2009// |
| /DOMEntityResolverTest2.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /DOMImplementationLSTest0.xml/1.6/Fri Apr 3 02:47:57 2009// |
| /DOMImplementationLSTest1.xml/1.7/Fri Apr 3 02:47:57 2009// |
| /DOMImplementationLSTest2.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /DOMImplementationLSTest3.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /DOMImplementationLSTest4.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /DOMImplementationLSTest5.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /DOMInputSourceTest0.xml/1.8/Fri Apr 3 02:47:58 2009// |
| /DOMInputSourceTest1.xml/1.8/Fri Apr 3 02:47:58 2009// |
| /DOMInputSourceTest2.xml/1.7/Fri Apr 3 02:47:57 2009// |
| /DOMInputSourceTest3.xml/1.9/Fri Apr 3 02:47:57 2009// |
| /DOMInputSourceTest4.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /DOMInputSourceTest5.xml/1.11/Fri Apr 3 02:47:57 2009// |
| /DOMInputSourceTest6.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /DOMWriterFilterTest0.xml/1.9/Fri Apr 3 02:47:57 2009// |
| /DOMWriterFilterTest1.xml/1.10/Fri Apr 3 02:47:57 2009// |
| /DOMWriterFilterTest2.xml/1.12/Fri Apr 3 02:47:57 2009// |
| /DOMWriterFilterTest3.xml/1.9/Fri Apr 3 02:47:57 2009// |
| /DOMWriterTest0.xml/1.8/Fri Apr 3 02:47:57 2009// |
| /DOMWriterTest1.xml/1.8/Fri Apr 3 02:47:58 2009// |
| /DOMWriterTest2.xml/1.8/Fri Apr 3 02:47:58 2009// |
| /DOMWriterTest3.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /DOMWriterTest4.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /DOMWriterTest5.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /DOMWriterTest6.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /GetFeature1.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /GetFeature2.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /HasFeature01.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /HasFeature02.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /HasFeature03.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /HasFeature04.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /HasFeature05.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /LSParserConfig1.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /LSParserConfig2.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /LSParserConfig3.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /LSParserConfig4.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /LSParserConfig5.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /LSParserConfig6.xml/1.6/Fri Apr 3 02:47:57 2009// |
| /LSParserConfig7.xml/1.6/Fri Apr 3 02:47:57 2009// |
| /LSParserConfig8.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /LSParserConfig9.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /LSSerializerConfig1.xml/1.6/Fri Apr 3 02:47:57 2009// |
| /LSSerializerConfig10.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /LSSerializerConfig2.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /LSSerializerConfig3.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /LSSerializerConfig4.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /LSSerializerConfig5.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /LSSerializerConfig6.xml/1.6/Fri Apr 3 02:47:57 2009// |
| /LSSerializerConfig7.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /LSSerializerConfig8.xml/1.7/Fri Apr 3 02:47:58 2009// |
| /LSSerializerConfig9.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /SystemId1.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /SystemId2.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /alltests.xml/1.22/Fri Apr 3 02:47:57 2009// |
| /canonicalform01.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /canonicalform03.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canonicalform04.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /canonicalform05.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /canonicalform06.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canonicalform08.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /canonicalform09.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /canonicalform10.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /canonicalform11.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canonicalform12.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /canonicalform13.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /cdatasections01.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /cdatasections02.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /cdatasections03.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /cdatasections04.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /checkcharacternormalization01.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /checkcharacternormalization02.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /checkcharacternormalization03.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /checkcharacternormalization04.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /comments01.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /comments02.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /comments03.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /comments04.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /datatypenormalization01.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /datatypenormalization02.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /datatypenormalization03.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization04.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization05.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization06.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /datatypenormalization07.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization08.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization09.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization10.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /datatypenormalization11.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /datatypenormalization12.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /datatypenormalization13.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization14.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /datatypenormalization15.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /datatypenormalization16.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /datatypenormalization17.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /disallowdoctype01.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /discarddefaultcontent01.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /discarddefaultcontent02.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /dom3tests.ent/1.15/Fri Apr 3 02:47:57 2009// |
| /elementcontentwhitespace01.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /elementcontentwhitespace02.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /elementcontentwhitespace03.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /encoding01.xml/1.2/Fri Apr 3 02:47:57 2009// |
| /entities01.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /entities02.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /entities03.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /entities04.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /entities05.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /entities06.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /entities07.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /entities08.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /entities09.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /infoset01.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /infoset02.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /infoset03.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /infoset04.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /infoset05.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /infoset06.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /infoset07.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /infoset08.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /metadata.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /namespacedeclarations01.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /namespacedeclarations02.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /namespaces01.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /namespaces02.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /newline01.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /newline02.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /newline03.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /noinputspecified01.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /nooutputspecified01.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /normalizecharacters01.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /normalizecharacters02.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /normalizecharacters03.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /normalizecharacters04.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /schemalocation01.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /schemalocation02.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /schemalocation03.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /schemalocation04.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /schematype01.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /schematype02.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /schematype03.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /schematype04.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /splitcdatasections01.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /splitcdatasections02.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /unsupportedencoding01.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /validate01.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /validate02.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /validate03.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /validate04.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /validate05.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /validate06.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /validate07.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /validate08.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /validateifschema01.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /validateifschema02.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /validateifschema03.xml/1.5/Fri Apr 3 02:47:57 2009// |
| /validateifschema04.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /wellformed01.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /wellformed02.xml/1.4/Fri Apr 3 02:47:57 2009// |
| /wellformed03.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /writeToURI1.xml/1.2/Fri Apr 3 02:47:57 2009// |
| /writeToURI2.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /xmldeclaration01.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /xmldeclaration02.xml/1.3/Fri Apr 3 02:47:57 2009// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/ls |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/CVS/Template |
|---|
| --- test/testcases/tests/level3/ls/CertifiedText1.xml (nonexistent) |
| +++ test/testcases/tests/level3/ls/CertifiedText1.xml (revision 4364) |
| @@ -0,0 +1,49 @@ |
| +<?xml version="1.0" standalone="no"?> |
| +<?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| +<!-- |
| + |
| +Copyright (c) 2003 World Wide Web Consortium, |
| +(Massachusetts Institute of Technology, Institut National de |
| +Recherche en Informatique et en Automatique, Keio University). All |
| +Rights Reserved. This program is distributed under the W3C's Software |
| +Intellectual Property License. This program is distributed in the |
| +hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| +PURPOSE. |
| + |
| +See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| + |
| +--> |
| +<!DOCTYPE test SYSTEM "dom3.dtd"> |
| + |
| + |
| +<test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="CertifiedText1"> |
| + <metadata> |
| + <title>CertifiedText1</title> |
| + <creator>Curt Arnold</creator> |
| + <description>Changes certifiedText on LSInput.</description> |
| + <date qualifier="created">2003-12-08</date> |
| + <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSInput"/> |
| + <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-certifiedText"/> |
| + </metadata> |
| + <var name="domImpl" type="DOMImplementationLS"/> |
| + <var name="input" type="LSInput"/> |
| + <var name="certifiedText" type="boolean"/> |
| + |
| + <implementation var="domImpl"/> |
| + <createLSInput var="input" obj="domImpl"/> |
| + <certifiedText var="certifiedText" obj="input"/> |
| + <assertFalse actual="certifiedText" id="initiallyFalse"/> |
| + <certifiedText obj="input" value="true"/> |
| + <certifiedText var="certifiedText" obj="input"/> |
| + <assertTrue actual="certifiedText" id="setTrue"/> |
| + |
| + <certifiedText obj="input" value="false"/> |
| + <certifiedText var="certifiedText" obj="input"/> |
| + <assertFalse actual="certifiedText" id="setFalse"/> |
| +</test> |
| + |
| + |
| + |
| + |
| + |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/CharacterStream1.xml |
|---|
| 0,0 → 1,84 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="CharacterStream1"> |
| <metadata> |
| <title>CharacterStream1</title> |
| <creator>Curt Arnold</creator> |
| <description>Writes a document to a character stream and rereads the document.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSInput"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-characterStream"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSOutput-characterStream"/> |
| </metadata> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="testDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="output" type="LSOutput"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="writer" type="LSWriter"/> |
| <var name="checkWriter" type="LSWriter"/> |
| <var name="reader" type="LSReader"/> |
| <var name="checkReader" type="LSReader"/> |
| <var name="status" type="boolean"/> |
| <var name="input" type="LSInput"/> |
| <var name="parser" type="LSParser"/> |
| <var name="checkDoc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemName" type="DOMString"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <load var="testDoc" href="test0" willBeModified="false"/> |
| <implementation var="domImpl"/> |
| <!-- create an LSOutput and connect it to an stock LSWriter --> |
| <createLSOutput var="output" obj="domImpl"/> |
| <!-- check that it was initially null --> |
| <characterStream var="checkWriter" obj="output" interface="LSOutput"/> |
| <assertNull actual="checkWriter" id="writerInitiallyNull"/> |
| <characterStream obj="output" value="writer" interface="LSOutput"/> |
| <characterStream var="checkWriter" obj="output" interface="LSOutput"/> |
| <assertNotNull actual="checkWriter" id="writerNotNull"/> |
| <!-- create a serializer and write a test document --> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <write var="status" obj="serializer" destination="output" nodeArg="testDoc"/> |
| <assertTrue actual="status" id="writeStatus"/> |
| <!-- read the serialized document --> |
| <assign var="reader" value="writer"/> |
| <createLSInput var="input" obj="domImpl"/> |
| <characterStream var="checkReader" obj="input" interface="LSInput"/> |
| <assertNull actual="checkReader" id="readerInitiallyNull"/> |
| <characterStream obj="input" value="reader" interface="LSInput"/> |
| <characterStream var="checkReader" obj="input" interface="LSInput"/> |
| <assertNotNull actual="checkReader" id="readerNotNull"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <parse var="checkDoc" obj="parser" input="input"/> |
| <assertNotNull actual="checkDoc" id="checkNotNull"/> |
| <documentElement var="docElem" obj="checkDoc"/> |
| <nodeName var="docElemName" obj="docElem"/> |
| <assertEquals expected='"elt0"' actual="docElemName" id="checkDocElemName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderFilterTest0.xml |
|---|
| 0,0 → 1,87 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMBuilderFilterTest0"> |
| <metadata> |
| <title>DOMBuilderFilterTest0</title> |
| &creator; |
| <description>Parses a document twice, once using a filter to reject all elt1 elements.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-filter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParserFilter-startElement"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParserFilter-whatToShow"/> |
| </metadata> |
| <var name="myfilter" type="LSParserFilter"> |
| <var name="name" type="DOMString"/> |
| &filterVars; |
| <startElement> |
| <nodeName var="name" obj="elementArg"/> |
| <if> |
| <equals actual="name" expected='"elt1"' ignoreCase="false"/> |
| <return value="&FILTER_REJECT;"/> |
| <else> |
| <return value="&FILTER_ACCEPT;"/> |
| </else> |
| </if> |
| </startElement> |
| <acceptNode> |
| <return value="&FILTER_ACCEPT;"/> |
| </acceptNode> |
| <whatToShow> |
| <get> |
| <return value="&SHOW_ELEMENT;"/> |
| </get> |
| </whatToShow> |
| </var> |
| <var name="list" type="NodeList"/> |
| <var name="count" type="int"/> |
| <var name="resourceURI" type="DOMString"/> |
| &vars; |
| &init; |
| <getResourceURI var="resourceURI" href="TEST1"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <getElementsByTagName var="list" obj="document" tagname=""elt1"" interface="Document"/> |
| <length var="count" obj="list" interface="NodeList"/> |
| <assertEquals actual="count" expected="1" ignoreCase="false" id="filter_count_1"/> |
| &parser.setFilter_myfilter; |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <assertNotNull actual="document" id="secondParseDocumentNotNull"/> |
| <getElementsByTagName var="list" obj="document" tagname=""elt1"" interface="Document"/> |
| <length var="count" obj="list" interface="NodeList"/> |
| <assertEquals actual="count" expected="0" ignoreCase="false" id="filter_count_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderFilterTest1.xml |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMBuilderFilterTest1"> |
| <metadata> |
| <title>DOMBuilderFilterTest1</title> |
| &creator; |
| <description>DOM Builder Filter test, test whether incorrect node types are never passed to the filter.</description> |
| &contributor; &date; |
| <subject resource="&spec;#LS-Interfaces-LSParserFilter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-filter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParserFilter-acceptNode"/> |
| </metadata> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="myfilter" type="LSParserFilter"> |
| &filterVars; |
| <startElement> |
| <return value="&FILTER_ACCEPT;"/> |
| </startElement> |
| <acceptNode> |
| <var name="type" type="int"/> |
| <nodeType obj="nodeArg" var="type"/> |
| <assertNotEquals actual="type" expected="2" id="attribute_node_test" ignoreCase="false"/> |
| <assertNotEquals actual="type" expected="6" id="entity_node_test" ignoreCase="false"/> |
| <assertNotEquals actual="type" expected="9" id="document_node_test" ignoreCase="false"/> |
| <assertNotEquals actual="type" expected="10" id="document_type_node_test" ignoreCase="false"/> |
| <assertNotEquals actual="type" expected="12" id="notation_node_test" ignoreCase="false"/> |
| <return value="&FILTER_ACCEPT;"/> |
| </acceptNode> |
| <whatToShow> |
| <get> |
| <return value="&SHOW_ALL;"/> |
| </get> |
| </whatToShow> |
| </var> |
| &vars; |
| &init; |
| &parser.setFilter_myfilter; |
| <getResourceURI var="resourceURI" href="TEST7"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <assertNotNull actual="document" id="documentNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderFilterTest2.xml |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMBuilderFilterTest2"> |
| <metadata> |
| <title>DOMBuilderFilterTest2</title> |
| &creator; |
| <description>Checks that attributes are visible when elements are passed to LSParserFilter.startElement.</description> |
| &contributor; &date; |
| <subject resource="&spec;#LS-Interfaces-LSParserFilter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParserFilter-startElement"/> |
| </metadata> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="myfilter" type="LSParserFilter"> |
| &filterVars; |
| <var name="name" type="DOMString"/> |
| <var name="hasattribute" type="boolean"/> |
| <startElement> |
| <nodeName var="name" obj="elementArg"/> |
| <if> |
| <equals actual="name" expected='"elt1"' ignoreCase="false"/> |
| <hasAttribute var="hasattribute" obj="elementArg" name='"attr1"'/> |
| <assertTrue actual="hasattribute" id="default_content_check"/> |
| </if> |
| <return value="&FILTER_ACCEPT;"/> |
| </startElement> |
| <acceptNode> |
| <return value="&FILTER_ACCEPT;"/> |
| </acceptNode> |
| <whatToShow> |
| <get> |
| <return value="&SHOW_ALL;"/> |
| </get> |
| </whatToShow> |
| </var> |
| &vars; |
| &init; |
| &parser.setFilter_myfilter; |
| <getResourceURI var="resourceURI" href="TEST3"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderTest0.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMBuilderTest0"> |
| <metadata> |
| <title>DOMBuilderTest0</title> |
| &creator; |
| <description>Parses a document, writes it to string, parses the string and checks that the number of elt1 elements is as expected.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parse"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-stringData"/> |
| </metadata> |
| <var name="elementList" type="NodeList"/> |
| <var name="stringDoc" type="DOMString"/> |
| <var name="resourceURI" type="DOMString"/> |
| &vars; |
| &init; |
| <getResourceURI var="resourceURI" href="TEST0" contentType="text/xml"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt1"" var="elementList"/> |
| <assertSize collection="elementList" size="2" id="count_elt1_1"/> |
| <writeToString var="stringDoc" obj="writer" nodeArg="document"/> |
| <stringData obj="inputSource" value="stringDoc"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt1"" var="elementList"/> |
| <assertSize collection="elementList" size="2" id="count_elt1_2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderTest1.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM 'dom3.dtd' [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="DOMBuilderTest1"> |
| <metadata> |
| <title>DOMBuilderTest1</title> |
| &creator; |
| <description>Uses LSParser.parseWithContext to replace a node in an existing document.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseWithContext"/> |
| </metadata> |
| <var name="elementList" type="NodeList"/> |
| <var name="stringDoc" type="DOMString"/> |
| <var name="firstElt2" type="Element"/> |
| <var name="returnNode" type="Node"/> |
| <var name="resourceURI" type="DOMString"/> |
| &vars; |
| &init; |
| <getResourceURI var="resourceURI" href="TEST0" contentType="text/xml"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt2"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="elt2Count_1"/> |
| <item interface="NodeList" obj="elementList" var="firstElt2" index="0"/> |
| <getResourceURI var="resourceURI" href="TEST2" contentType="text/xml"/> |
| <systemId obj="inputSource" value="resourceURI" interface="LSInput"/> |
| <try> |
| <parseWithContext obj="parser" input="inputSource" |
| contextArg="firstElt2" action="ACTION_REPLACE" var="returnNode"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt2"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="elt2Count_2"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt3"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="elt3Count"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderTest2.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMBuilderTest2"> |
| <metadata> |
| <title>DOMBuilderTest2</title> |
| &creator; |
| <description>Uses LSParser.parseWithContext to append a document as a child of an existing node.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseWithContext"/> |
| </metadata> |
| <var name="elementList" type="NodeList"/> |
| <var name="stringDoc" type="DOMString"/> |
| <var name="firstElt0" type="Element"/> |
| <var name="returnNode" type="Node"/> |
| <var name="resourceURI" type="DOMString"/> |
| &vars; |
| &init; |
| <getResourceURI var="resourceURI" href="TEST0" contentType="text/xml"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt0"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="count_elt0"/> |
| <item interface="NodeList" obj="elementList" var="firstElt0" index="0"/> |
| <getResourceURI var="resourceURI" href="TEST2" contentType="text/xml"/> |
| <systemId obj="inputSource" value="resourceURI" interface="LSInput"/> |
| <try> |
| <parseWithContext obj="parser" input="inputSource" contextArg="firstElt0" action="ACTION_APPEND_AS_CHILDREN" var="returnNode"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt2"" var="elementList"/> |
| <assertSize collection="elementList" size="2" id="count_elt2"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt3"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="count_elt3"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderTest3.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMBuilderTest3"> |
| <metadata> |
| <title>DOMBuilderTest3</title> |
| &creator; |
| <description>Uses LSParser.parseWithContext to insert a document after a node.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseWithContext"/> |
| </metadata> |
| <var name="elementList" type="NodeList"/> |
| <var name="stringDoc" type="DOMString"/> |
| <var name="firstElt1" type="Element"/> |
| <var name="secondElt1" type="Element"/> |
| <var name="thirdElt" type="Element"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="returnNode" type="Node"/> |
| <var name="resourceURI" type="DOMString"/> |
| &vars; |
| &init; |
| <getResourceURI var="resourceURI" href="TEST0" contentType="text/xml"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt1"" var="elementList"/> |
| <assertSize collection="elementList" size="2" id="count_elt1"/> |
| <item interface="NodeList" obj="elementList" var="firstElt1" index="0"/> |
| <nextSibling interface="Node" obj="firstElt1" var="secondElt1"/> |
| <nodeName obj="secondElt1" var="nodeName"/> |
| <assertEquals actual="nodeName" expected=""elt1"" id="nextSibling_before_add" ignoreCase="false"/> |
| <getResourceURI var="resourceURI" href="TEST2" contentType="text/xml"/> |
| <systemId obj="inputSource" value="resourceURI" interface="LSInput"/> |
| <try> |
| <parseWithContext obj="parser" input="inputSource" contextArg="firstElt1" action="ACTION_INSERT_AFTER" var="returnNode"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <nextSibling interface="Node" obj="firstElt1" var="secondElt1"/> |
| <nodeName obj="secondElt1" var="nodeName"/> |
| <assertEquals actual="nodeName" expected=""elt2"" id="nextSibling_after_add" ignoreCase="false"/> |
| <nextSibling interface="Node" obj="secondElt1" var="thirdElt"/> |
| <nodeName obj="thirdElt" var="nodeName"/> |
| <assertEquals actual="nodeName" expected=""elt1"" id="nextSiblings_sibling_after_add" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderTest4.xml |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMBuilderTest4"> |
| <metadata> |
| <title>DOMBuilderTest4</title> |
| &creator; |
| <description>Uses LSParser.parseWithContext to insert a document before a node.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseWithContext"/> |
| </metadata> |
| <var name="elementList" type="NodeList"/> |
| <var name="stringDoc" type="DOMString"/> |
| <var name="firstElt1" type="Element"/> |
| <var name="secondElt1" type="Element"/> |
| <var name="thirdElt" type="Element"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="returnNode" type="Node"/> |
| <var name="resourceURI" type="DOMString"/> |
| &vars; |
| &init; |
| <getResourceURI var="resourceURI" href="TEST0" contentType="text/xml"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt1"" var="elementList"/> |
| <assertSize collection="elementList" size="2" id="count_elt1"/> |
| <item interface="NodeList" obj="elementList" var="secondElt1" index="1"/> |
| <previousSibling interface="Node" obj="secondElt1" var="firstElt1"/> |
| <nodeName obj="firstElt1" var="nodeName"/> |
| <assertEquals actual="nodeName" expected=""elt1"" id="previousSibling_before_insert_before" ignoreCase="false"/> |
| <getResourceURI var="resourceURI" href="TEST2" contentType="text/xml"/> |
| <systemId obj="inputSource" value="resourceURI" interface="LSInput"/> |
| <try> |
| <parseWithContext obj="parser" input="inputSource" contextArg="secondElt1" action="ACTION_INSERT_BEFORE" var="returnNode"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <previousSibling interface="Node" obj="secondElt1" var="firstElt1"/> |
| <nodeName obj="firstElt1" var="nodeName"/> |
| <assertEquals actual="nodeName" expected=""elt2"" id="previousSibling_after_insert_before" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderTest5.xml |
|---|
| 0,0 → 1,81 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"[ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMBuilderTest5"> |
| <metadata> |
| <title>DOMBuilderTest5</title> |
| &creator; |
| <description>supported-media-types-only is set to true if supported and |
| an XML file with an unsupported media type from an HTTP server |
| on the local machine is retrieved.</description> |
| &contributor; &date; |
| <subject resource="&spec;#LS-LSParser-parseURI"/> |
| <subject resource="&spec;#parameter-supported-media-types-only"/> |
| </metadata> |
| <var name="elementList" type="NodeList"/> |
| <var name="stringDoc" type="DOMString"/> |
| <var name="configuration" type="DOMConfiguration"/> |
| <var name="ERROR_HANDLER" type="DOMString" value='"error-handler"'/> |
| <var name="SUPPORTED_MEDIATYPES_ONLY" type="DOMString" value='"supported-media-types-only"'/> |
| <var name="mediaTypesSupported" type="boolean"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="errorHandler" type="DOMErrorHandler"> |
| <handleError> |
| <var name="type" type="DOMString"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <assertEquals id="handler_1" actual="type" expected='"unsupported-media-type"' ignoreCase="false"/> |
| <return value="false"/> |
| </handleError> |
| </var> |
| &vars; |
| &init; |
| <domConfig var="configuration" obj="parser" interface="LSParser"/> |
| <getResourceURI var="resourceURI" href="TESTPDF" scheme="http" contentType="application/pdf"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <!-- |
| document should successfully parse since, properly configured, |
| testpdf.pdf is a valid XML file on the http server. |
| --> |
| <assertNotNull actual="document" id="testpdf_parsed"/> |
| <canSetParameter var="mediaTypesSupported" obj="configuration" name="SUPPORTED_MEDIATYPES_ONLY" value="true"/> |
| <if> |
| <isTrue value="mediaTypesSupported"/> |
| <setParameter obj="configuration" name="SUPPORTED_MEDIATYPES_ONLY" value="true"/> |
| <setParameter obj="configuration" name="ERROR_HANDLER" value="errorHandler"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderTest6.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="DOMBuilderTest6"> |
| <metadata> |
| <title>DOMBuilderTest6</title> |
| <creator>Curt Arnold</creator> |
| <description>Parses from an uninitialized LSInput.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parse"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <var name="input" type="LSInput"/> |
| <var name="document" type="Document"/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <createLSInput var="input" obj="domImpl"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parse var="document" obj="parser" input="input"/> |
| </PARSE_ERR> |
| </assertLSException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMBuilderTest8.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="DOMBuilderTest8"> |
| <metadata> |
| <title>DOMBuilderTest8</title> |
| <creator>Curt Arnold</creator> |
| <description>Parses an unresolvable System ID.</description> |
| <date qualifier="created">2003-12-19</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parse"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <var name="input" type="LSInput"/> |
| <var name="document" type="Document"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <createLSInput var="input" obj="domImpl"/> |
| <getResourceURI var="resourceURI" href='"test0"' contentType="text/xml"/> |
| <plus var="resourceURI" op1="resourceURI" op2='"_missing"'/> |
| <systemId obj="input" value="resourceURI" interface="LSInput"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parse var="document" obj="parser" input="input"/> |
| </PARSE_ERR> |
| </assertLSException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMEntityResolverTest0.xml |
|---|
| 0,0 → 1,75 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMEntityResolverTest0"> |
| <metadata> |
| <title>DOMEntityResolverTest0</title> |
| &creator; |
| <description>Checks parameters on call to resolve resource are |
| as expected and redirects to parse a different resource.</description> |
| &contributor; &date; |
| <subject resource="&spec;#LS-LSResourceResolver-resolveResource"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-resource-resolver"/> |
| </metadata> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="elt2List" type="NodeList"/> |
| <var name="elt2Count" type="int"/> |
| <var name="myentityresolver" type="LSResourceResolver"> |
| <resolveResource> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="redirectedInput" type="LSInput"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="source" type="DOMString" value='"<elt2/>"'/> |
| <!-- check that parameters on call to resolveSource are correct --> |
| <assertNull actual="publicId" id="rr_publicId"/> |
| <assertEquals actual="systemId" expected='"test5.xml"' ignoreCase="false" id="rr_systemId"/> |
| <assertURIEquals actual="baseURI" isAbsolute='true' name='"test4"' id="rr_baseURI"/> |
| <!-- redirect so that test5 is loaded --> |
| <implementation var="domImplLS"/> |
| <createLSInput var="redirectedInput" obj="domImplLS"/> |
| <stringData obj="redirectedInput" value="source" interface="LSInput"/> |
| <return value="redirectedInput"/> |
| </resolveResource> |
| </var> |
| <var name="configuration" type="DOMConfiguration"/> |
| &vars; |
| &init; |
| <domConfig var="configuration" obj="parser" interface="LSParser"/> |
| <setParameter obj="configuration" name='"resource-resolver"' value="myentityresolver"/> |
| <getResourceURI var="resourceURI" href="TEST4" contentType="text/xml"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <getElementsByTagName var="elt2List" obj="document" |
| tagname='"elt2"' interface="Document"/> |
| <length var="elt2Count" obj="elt2List" interface="NodeList"/> |
| <assertEquals actual="elt2Count" expected="1" id="elt2Count" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMEntityResolverTest1.xml |
|---|
| 0,0 → 1,79 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMEntityResolverTest1"> |
| <metadata> |
| <title>DOMEntityResolverTest1</title> |
| &creator; |
| <description>Tests a custom entity resolver. The entity resolver creates an input source that supplies 2 elt1 elements. The original entity reference referes to 1 elt1</description> |
| &contributor; &date; |
| <subject resource="&spec;#LS-LSResourceResolver-resolveResource"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-resource-resolver"/> |
| </metadata> |
| <implementationAttribute name="validating" value="true"/> |
| <var name="myentityresolver" type="LSResourceResolver"> |
| <resolveResource> |
| <var name="erInputSource" type="LSInput"/> |
| <var name='implementation' type='DOMImplementation'/> |
| <var name='lsImplementation' type='DOMImplementationLS'/> |
| <var name="substitute" type="DOMString" value='"<elt1>second elt1</elt1><elt1>third elt1</elt1>"'/> |
| <implementation var='implementation'/> |
| <assign var='lsImplementation' value='implementation'/> |
| <createLSInput var='erInputSource' obj='lsImplementation'/> |
| <stringData obj="erInputSource" value="substitute" interface="LSInput"/> |
| <return value="erInputSource"/> |
| </resolveResource> |
| </var> |
| <var name="elementList" type="NodeList"/> |
| <var name="configuration" type="DOMConfiguration"/> |
| <var name="resourceURI" type="DOMString"/> |
| &vars; |
| &init; |
| <domConfig var="configuration" obj="parser" interface="LSParser"/> |
| <getResourceURI var="resourceURI" href="TEST4" contentType="text/xml"/> |
| <!-- before applying the entity resolver there should be 2 elt1 in this document --> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt1"" var="elementList"/> |
| <assertSize collection="elementList" size="2" id="count_elt1_before_applying_entity_resolver"/> |
| <setParameter obj="configuration" name='"resource-resolver"' value="myentityresolver"/> |
| <!-- after applying the entity resolver there should be 3 elt1 in this document --> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt1"" var="elementList"/> |
| <assertSize collection="elementList" size="3" id="count_elt1_after_applying_entity_resolver"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMEntityResolverTest2.xml |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMEntityResolverTest2"> |
| <metadata> |
| <title>DOMEntityResolverTest2</title> |
| &creator; |
| <description>Resource resolvers do not participate in resolving the top-level document entity. |
| This test attempts to redirect any resource and then checks that the |
| requested document was not affected.</description> |
| &contributor; &date; |
| <subject resource="&spec;#LS-LSResourceResolver-resolveResource"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-resource-resolver"/> |
| </metadata> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemName" type="DOMString"/> |
| <var name="myentityresolver" type="LSResourceResolver"> |
| <resolveResource> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="redirectedInput" type="LSInput"/> |
| <var name="source" type="DOMString" value='"<!DOCTYPE failure [<!ELEMENT failure EMPTY>]><failure/>"'/> |
| <!-- |
| The resolveResource should not be invoked, |
| but if it is substitute a failure document --> |
| <implementation var="domImplLS"/> |
| <createLSInput var="redirectedInput" obj="domImplLS"/> |
| <stringData obj="redirectedInput" value="source" interface="LSInput"/> |
| <return value="redirectedInput"/> |
| </resolveResource> |
| </var> |
| <var name="configuration" type="DOMConfiguration"/> |
| &vars; |
| &init; |
| <domConfig var="configuration" obj="parser" interface="LSParser"/> |
| <setParameter obj="configuration" name='"resource-resolver"' value="myentityresolver"/> |
| <getResourceURI var="resourceURI" href="TEST0" contentType="text/xml"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <assertNotNull actual="document" id="documentNotNull"/> |
| <documentElement var="docElem" obj="document"/> |
| <nodeName var="docElemName" obj="docElem"/> |
| <assertEquals actual="docElemName" expected='"elt0"' |
| id="docElemName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMImplementationLSTest0.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMImplementationLSTest0"> |
| <metadata> |
| <title>DOMImplementationLSTest0</title> |
| &creator; |
| <description>Uses DOMImplementationLS.createLSParser to create a synchronous parser with an unspecified schema type.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSParser"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-async"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-busy"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-filter"/> |
| </metadata> |
| <var name="isAsync" type="boolean"/> |
| <var name="isBusy" type="boolean"/> |
| <var name="filter" type="LSParserFilter"/> |
| &vars; |
| <createLSParser var='parser' obj='lsImplementation' mode='MODE_SYNCHRONOUS' schemaType='NULL_SCHEMATYPE'/> |
| <assertNotNull actual="parser" id="parserNotNull"/> |
| <async var="isAsync" obj="parser"/> |
| <assertFalse actual="isAsync" id="notAsync"/> |
| <busy var="isBusy" obj="parser"/> |
| <assertFalse actual="isBusy" id="notBusy"/> |
| <filter var="filter" obj="parser" interface="LSParser"/> |
| <assertNull actual="filter" id="nullFilter"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMImplementationLSTest1.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMImplementationLSTest1"> |
| <metadata> |
| <title>DOMImplementationLSTest1</title> |
| &creator; |
| <description>Calls DOMImplementationLS.createLSParser(MODE_ASYNCHRONOUS, null) and |
| checks the return value is not null. Only applicable if DOMImplementation.hasFeature("LS-ASync", null) is true.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSParser"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-async"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-busy"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-filter"/> |
| </metadata> |
| <hasFeature feature='"LS-Async"'/> |
| <var name="isAsync" type="boolean"/> |
| <var name="isBusy" type="boolean"/> |
| <var name="filter" type="LSParserFilter"/> |
| &vars; |
| <createLSParser var='parser' obj='lsImplementation' mode='MODE_ASYNCHRONOUS' schemaType='NULL_SCHEMATYPE'/> |
| <assertNotNull actual="parser" id="parserNotNull"/> |
| <async var="isAsync" obj="parser"/> |
| <assertTrue actual="isAsync" id="notAsync"/> |
| <busy var="isBusy" obj="parser"/> |
| <assertFalse actual="isBusy" id="notBusy"/> |
| <filter var="filter" obj="parser" interface="LSParser"/> |
| <assertNull actual="filter" id="nullFilter"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMImplementationLSTest2.xml |
|---|
| 0,0 → 1,38 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMImplementationLSTest2"> |
| <metadata> |
| <title>DOMImplementationLSTest2</title> |
| &creator; |
| <description>Calls DOMImplementationLS.createLSParser(MODE_SYNCHRONOUS, "http://www.w3.org/TR/REC-xml") and checks the return value is not null.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSParser"/> |
| </metadata> |
| &vars; |
| <createLSParser var='parser' obj='lsImplementation' mode='MODE_SYNCHRONOUS' schemaType='DTD_SCHEMATYPE'/> |
| <assertNotNull actual="parser" id="parserNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMImplementationLSTest3.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMImplementationLSTest3"> |
| <metadata> |
| <title>DOMImplementationLSTest3</title> |
| &creator; |
| <description>Calls DOMImplementationLS.createLSParser(MODE_SYNCHRONOUS, "http://www.w3.org/2001/XMLSchema"). |
| Should either throw a NOT_SUPPORTED_ERR or return a non-null parser.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSParser"/> |
| </metadata> |
| &vars; |
| <try> |
| <createLSParser var='parser' obj='lsImplementation' mode='MODE_SYNCHRONOUS' schemaType='SCHEMA_SCHEMATYPE'/> |
| <assertNotNull actual="parser" id="parserNotNull"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"/> |
| </catch> |
| </try> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMImplementationLSTest4.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMImplementationLSTest4"> |
| <metadata> |
| <title>DOMImplementationLSTest4</title> |
| &creator; |
| <description>Calls DOMImplementationLS.createLSParser(MODE_SYNCHRONOUS, "http://nobody...err") expecting that a |
| NOT_SUPPORTED_ERR would be raised.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSParser"/> |
| </metadata> |
| &vars; |
| <assertDOMException id="NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createLSParser var='parser' obj='lsImplementation' |
| mode='MODE_SYNCHRONOUS' |
| schemaType='"http://nobody_should_support_this_schematype_this_should_throw_a_not_supported_err"'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMImplementationLSTest5.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMImplementationLSTest5"> |
| <metadata> |
| <title>DOMImplementationLSTest0</title> |
| &creator; |
| <description>Calls DOMImplementationLS.createLSParser(MODE_SYNCHRONOUS, "http://nobody...err") expecting that a |
| NOT_SUPPORTED_ERR would be raised.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSParser"/> |
| </metadata> |
| &vars; |
| <assertDOMException id="NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <createLSParser var='parser' obj='lsImplementation' |
| mode='17' |
| schemaType='NULL_SCHEMATYPE'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMInputSourceTest0.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMInputSourceTest0"> |
| <metadata> |
| <title>DOMInputSourceTest0</title> |
| &creator; |
| <description>Parses a document from a byte stream.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-byteStream"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parse"/> |
| </metadata> |
| <!-- stream value is <elt0/> in UTF-8 --> |
| <var name="myByteStream" type="LSInputStream" value='"3C656C74302F3E"'/> |
| <var name="elementList" type="NodeList"/> |
| &vars; |
| &init; |
| <byteStream obj="inputSource" value="myByteStream" interface="LSInput"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt0"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="count_elt0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMInputSourceTest1.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMInputSourceTest1"> |
| <metadata> |
| <title>DOMInputSourceTest1</title> |
| &creator; |
| <description>Parses a document from a character stream.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-characterStream"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parse"/> |
| </metadata> |
| <var name="myReader" type="LSReader" value='"<elt0/>"'/> |
| <var name="elementList" type="NodeList"/> |
| &vars; |
| &init; |
| <characterStream obj="inputSource" value="myReader" interface="LSInput"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt0"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="count_elt0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMInputSourceTest2.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMInputSourceTest2"> |
| <metadata> |
| <title>DOMInputSourceTest2</title> |
| &creator; |
| <description>test the parser by using a string inputsource</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-stringData"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parse"/> |
| </metadata> |
| <var name="elementList" type="NodeList"/> |
| <var name="myString" type="DOMString" value=""<elt0>elt0</elt0>""/> |
| &vars; |
| &init; |
| <stringData obj="inputSource" value="myString" interface="LSInput"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt0"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="count_elt0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMInputSourceTest3.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMInputSourceTest3"> |
| <metadata> |
| <title>DOMInputSourceTest3</title> |
| &creator; |
| <description>Specify encodings for LSInput with string data. The |
| setting should have no effect and the inputEncoding of the resulting document should be UTF-16.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-encoding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parse"/> |
| </metadata> |
| <hasFeature feature='"Core"' version='"3.0"'/> |
| <var name="myString" type="DOMString" value=""<?xml version='1.0' encoding='UTF-8'?><elt0>elt0</elt0>""/> |
| <var name="encodingString" type="DOMString"/> |
| &vars; |
| &init; |
| <!-- initialize an input source with a string and a misleading encoding --> |
| <stringData obj="inputSource" value="myString" interface="LSInput"/> |
| <encoding obj="inputSource" value='"UTF-8"' interface="LSInput"/> |
| <!-- parse --> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- check inputEncoding, should be UTF-16 --> |
| <inputEncoding var="encodingString" obj="document" interface="Document"/> |
| <assertEquals actual="encodingString" expected='"UTF-16"' ignoreCase="true" id="encodingstringcheck0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMInputSourceTest4.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMInputSourceTest4"> |
| <metadata> |
| <title>DOMInputSourceTest4</title> |
| &creator; |
| <description>tests whether DOMInput whether abort can be called even if loading is finished already</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-abort"/> |
| </metadata> |
| <var name="elementList" type="NodeList"/> |
| <var name="myString" type="DOMString" value=""<?xml version='1.0' encoding='UTF-8'?><elt0>elt0</elt0>""/> |
| &vars; |
| &init; |
| <stringData obj="inputSource" value="myString" interface="LSInput"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- abort should be possible even in synchronous load --> |
| <abort obj="parser" interface="LSParser"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMInputSourceTest5.xml |
|---|
| 0,0 → 1,88 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMInputSourceTest5"> |
| <metadata> |
| <title>DOMInputSourceTest5</title> |
| &creator; |
| <description>Parses a document containing an external entity and checks |
| that resource resolver is passed the baseURI value specified on LSInput.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-systemId"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-publicId"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-baseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSResourceResolver-resolveResource"/> |
| </metadata> |
| <var name="myentityresolver" type="LSResourceResolver"> |
| <resolveResource> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="input" type="LSInput"/> |
| <assertEquals actual="baseURI" expected='"http://www.example.com/new_base"' ignoreCase="false" id="er_base"/> |
| <assertEquals actual="publicId" expected='"-//X-Hive//native xml storage//EN"' ignoreCase="false" id="er_public"/> |
| <assertURIEquals actual="systemId" isAbsolute="true" name='"test5"' id="er_system"/> |
| <!-- create an empty string input so we can detect |
| that resource resolver was used --> |
| <implementation var="domImplLS"/> |
| <createLSInput var="input" obj="domImplLS"/> |
| <stringData obj="input" value='""' interface="LSInput"/> |
| <return value="input"/> |
| </resolveResource> |
| </var> |
| <var name="configuration" type="DOMConfiguration"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="nodeList" type="NodeList"/> |
| &vars; |
| &init; |
| <domConfig var="configuration" obj="parser" interface="LSParser"/> |
| <setParameter obj="configuration" name='"resource-resolver"' value="myentityresolver"/> |
| <setParameter obj="configuration" name='"entities"' value="false"/> |
| <getResourceURI var="resourceURI" href="TEST4" contentType="text/xml"/> |
| <systemId obj="inputSource" value="resourceURI" interface="LSInput"/> |
| <publicId obj="inputSource" value='"-//X-Hive//native xml storage//DE"' interface="LSInput"/> |
| <baseURI obj="inputSource" value='"http://www.example.com/new_base"' interface="LSInput"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- should parse successfully --> |
| <assertNotNull actual="document" id="documentNotNull"/> |
| <!-- resource resolver should have suppressed elt2 from the |
| external entity --> |
| <getElementsByTagName var="nodeList" obj="document" tagname='"elt2"' interface="Document"/> |
| <assertSize size="0" collection="nodeList" id="noElt2"/> |
| <!-- check that there is an elt1 --> |
| <getElementsByTagName var="nodeList" obj="document" tagname='"elt1"' interface="Document"/> |
| <assertSize size="1" collection="nodeList" id="hasElt1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMInputSourceTest6.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMInputSourceTest6"> |
| <metadata> |
| <title>DOMInputSourceTest6</title> |
| &creator; |
| <description>Specify encodings for LSInput with a character stream. The |
| setting should have no effect and the inputEncoding of the resulting document should be UTF-16.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-encoding"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parse"/> |
| </metadata> |
| <hasFeature feature='"Core"' version='"3.0"'/> |
| <var name="encodingString" type="DOMString"/> |
| <var name="myReader" type="LSReader" value=""<?xml version='1.0' encoding='UTF-8'?><elt0>elt0</elt0>""/> |
| &vars; |
| &init; |
| <!-- initialize an input source with a string and a misleading encoding --> |
| <encoding obj="inputSource" value='"UTF-8"' interface="LSInput"/> |
| <characterStream obj="inputSource" value="myReader" interface="LSInput"/> |
| <!-- parse --> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <assertNotNull actual="document" id="documentNotNull"/> |
| <!-- check inputEncoding, should be UTF-16 --> |
| <inputEncoding var="encodingString" obj="document" interface="Document"/> |
| <assertEquals actual="encodingString" expected='"UTF-16"' ignoreCase="true" id="encodingstringcheck0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterFilterTest0.xml |
|---|
| 0,0 → 1,95 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMWriterFilterTest0"> |
| <metadata> |
| <title>DOMWriterFilterTest0</title> |
| &creator; |
| <description>DOMSerializerFilter test, a simple test eliminating a subtree</description> |
| &contributor; &date; |
| <subject resource="&spec;#LS-Interfaces-LSSerializerFilter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-LSSerializerFilter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializerFilter-acceptNode"/> |
| </metadata> |
| <var name="myfilter" type="LSSerializerFilter"> |
| <var name="name" type="DOMString"/> |
| &filterVars; |
| <acceptNode> |
| <nodeName obj="n" var="name"/> |
| <if> |
| <equals actual="name" expected='"elt1"' ignoreCase="false"/> |
| <return value="&FILTER_ACCEPT;"/> |
| </if> |
| <return value="&FILTER_REJECT;"/> |
| </acceptNode> |
| <whatToShow> |
| <get> |
| <return value="&SHOW_ALL;"/> |
| </get> |
| </whatToShow> |
| </var> |
| <var name="configuration" type="DOMConfiguration"/> |
| <var name="stringDoc" type="DOMString" value='"<elt1>first elt1<elt2>elt2</elt2></elt1>"'/> |
| <var name="writeResult" type="DOMString"/> |
| <var name="length" type="int"/> |
| <var name="elementList" type="NodeList"/> |
| &vars; |
| &init; |
| <!-- parse the string --> |
| <stringData obj="inputSource" value="stringDoc"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- apply the filter --> |
| <filter obj="writer" value="myfilter" interface="LSSerializer"/> |
| <!-- serialize result --> |
| <writeToString var="writeResult" obj="writer" nodeArg="document"/> |
| <!-- parse result --> |
| <stringData obj="inputSource" value="writeResult" interface="LSInput"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- tests elt1 should be in the result, elt2 should be filtered out --> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt2"" var="elementList"/> |
| <assertSize collection="elementList" size="0" id="count_elt2"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt1"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="count_elt1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterFilterTest1.xml |
|---|
| 0,0 → 1,90 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMWriterFilterTest1"> |
| <metadata> |
| <title>DOMWriterFilterTest1</title> |
| &creator; |
| <description>Uses a serializer filter to eliminate attributes, parses the output and checks if the attribute is not there.</description> |
| &contributor; &date; |
| <subject resource="&spec;#LS-Interfaces-LSSerializerFilter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-LSSerializerFilter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializerFilter-acceptNode"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializerFilter-whatToShow"/> |
| </metadata> |
| <var name="myfilter" type="LSSerializerFilter"> |
| &filterVars; |
| <acceptNode> |
| <return value="&FILTER_REJECT;"/> |
| </acceptNode> |
| <whatToShow> |
| <get> |
| <return value="&SHOW_ATTRIBUTE;"/> |
| </get> |
| </whatToShow> |
| </var> |
| <var name="configuration" type="DOMConfiguration"/> |
| <var name="stringDoc" type="DOMString" value=""<elt1 attr1='attr1'>first elt1</elt1>""/> |
| <var name="writeResult" type="DOMString"/> |
| <var name="length" type="int"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elt1" type="Element"/> |
| <var name="attrNode" type="Attr"/> |
| &vars; |
| &init; |
| <!-- parse the string --> |
| <stringData obj="inputSource" value="stringDoc"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- apply the filter --> |
| <filter obj="writer" value="myfilter" interface="LSSerializer"/> |
| <!-- serialize result --> |
| <writeToString var="writeResult" obj="writer" nodeArg="document"/> |
| <!-- parse result --> |
| <stringData obj="inputSource" value="writeResult" interface="LSInput"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- tests elt1 should be in the result--> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt1"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="count_elt2"/> |
| <!-- attr1 of elt1 should have been suppressed --> |
| <item interface="NodeList" obj="elementList" index="0" var="elt1"/> |
| <getAttributeNode obj="elt1" var="attrNode" name=""attr1""/> |
| <assertNull actual="attrNode" id="attrib1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterFilterTest2.xml |
|---|
| 0,0 → 1,99 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMWriterFilterTest2"> |
| <metadata> |
| <title>DOMWriterFilterTest2</title> |
| &creator; |
| <description>Uses a filter to strip text during serialization |
| parsers to check expections.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-LSSerializerFilter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializerFilter-acceptNode"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializerFilter-whatToShow"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=643"/> |
| </metadata> |
| <var name="myfilter" type="LSSerializerFilter"> |
| <var name="name" type="DOMString"/> |
| &filterVars; |
| <acceptNode> |
| <return value="&FILTER_REJECT;"/> |
| </acceptNode> |
| <whatToShow> |
| <get> |
| <return value="&SHOW_TEXT;"/> |
| </get> |
| </whatToShow> |
| </var> |
| <var name="stringDoc" type="DOMString" value=""<elt1 attr1='attr1'>first elt1</elt1>""/> |
| <var name="writeResult" type="DOMString"/> |
| <var name="length" type="int"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="elt1" type="Element"/> |
| <var name="childs" type="boolean"/> |
| <var name="attrNode" type="Attr"/> |
| <var name="attr1" type="DOMString"/> |
| &vars; |
| &init; |
| <!-- parse the string --> |
| <stringData obj="inputSource" value="stringDoc"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- apply the filter --> |
| <filter obj="writer" value="myfilter" interface="LSSerializer"/> |
| <!-- serialize result --> |
| <writeToString var="writeResult" obj="writer" nodeArg="document"/> |
| <!-- parse result --> |
| <stringData obj="inputSource" value="writeResult" interface="LSInput"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- tests no child of elt1--> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt1"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" index="0" var="elt1"/> |
| <!-- attr not effected since children of attribute nodes not passed to filter --> |
| <getAttributeNode var="attrNode" obj="elt1" name='"attr1"'/> |
| <assertNotNull actual="attrNode" id="attrExists"/> |
| <nodeValue var="attr1" obj="attrNode"/> |
| <assertEquals actual="attr1" expected='"attr1"' ignoreCase="false" id="attrUnchanged"/> |
| <!-- elt1 should be empty --> |
| <hasChildNodes obj="elt1" var="childs"/> |
| <assertFalse actual="childs" id="nodeHasChilds_elt1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterFilterTest3.xml |
|---|
| 0,0 → 1,87 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMWriterFilterTest3"> |
| <metadata> |
| <title>DOMWriterFilterTest3</title> |
| &creator; |
| <description>Eliminates comments on serialization, parses results and checks for comments.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-LSSerializerFilter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializerFilter-acceptNode"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializerFilter-whatToShow"/> |
| </metadata> |
| <var name="myfilter" type="LSSerializerFilter"> |
| &filterVars; |
| <acceptNode> |
| <return value="&FILTER_REJECT;"/> |
| </acceptNode> |
| <whatToShow> |
| <get> |
| <return value="&SHOW_COMMENT;"/> |
| </get> |
| </whatToShow> |
| </var> |
| <var name="configuration" type="DOMConfiguration"/> |
| <var name="stringDoc" type="DOMString" value=""<elt1><elt2>elt2</elt2><!--comment1--></elt1>""/> |
| <var name="writeResult" type="DOMString"/> |
| <var name="length" type="int"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="children" type="NodeList"/> |
| <var name="elt1" type="Element"/> |
| &vars; |
| &init; |
| <!-- parse the string --> |
| <stringData obj="inputSource" value="stringDoc"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- apply the filter --> |
| <filter obj="writer" value="myfilter" interface="LSSerializer"/> |
| <!-- serialize result --> |
| <writeToString var="writeResult" obj="writer" nodeArg="document"/> |
| <!-- parse result --> |
| <stringData obj="inputSource" value="writeResult" interface="LSInput"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- test comments should be deleted, one child left of elt1 --> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt1"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="count_elt1"/> |
| <item interface="NodeList" obj="elementList" index="0" var="elt1"/> |
| <childNodes obj="elt1" var="children"/> |
| <assertSize collection="children" size="1" id="count_children"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterTest0.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMWriterTest0"> |
| <metadata> |
| <title>DOMWriterTest0</title> |
| &creator; |
| <description>Calls LSSerializer.writeToString and checks result.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| </metadata> |
| <var name="stringDoc" type="DOMString"/> |
| <var name="writeResult" type="DOMString"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="resourceURI" type="DOMString"/> |
| &vars; |
| &init; |
| <getResourceURI var="resourceURI" href="TEST0"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <writeToString var="writeResult" obj="writer" nodeArg="document"/> |
| <stringData obj="inputSource" value="writeResult"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt2"" var="elementList"/> |
| <assertSize collection="elementList" size="1" id="elt2Count_1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterTest1.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMWriterTest1"> |
| <metadata> |
| <title>DOMWriterTest1</title> |
| &creator; |
| <description>Writes an element node to a byte stream.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSOutput-byteStream"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-write"/> |
| </metadata> |
| <var name="stringDoc" type="DOMString"/> |
| <var name="writeResult" type="boolean"/> |
| <var name="elementList" type="NodeList"/> |
| <var name="firstElt3" type="Node"/> |
| <var name="output" type="LSOutput"/> |
| <var name="outputStream" type="LSOutputStream"/> |
| <var name="inputStream" type="LSInputStream" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| &vars; |
| &init; |
| <!-- write out only subtree with elt3--> |
| <getResourceURI var="resourceURI" href="TEST2"/> |
| <parseURI var="document" obj="parser" uri="resourceURI"/> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt3"" var="elementList"/> |
| <item interface="NodeList" obj="elementList" var="firstElt3" index="0"/> |
| <createLSOutput var="output" obj="lsImplementation"/> |
| <byteStream obj="output" value="outputStream" interface="LSOutput"/> |
| <write var="writeResult" obj="writer" destination="output" nodeArg="firstElt3"/> |
| <assign var="inputStream" value="outputStream"/> |
| <byteStream obj="inputSource" value="inputStream" interface="LSInput"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- no elt2 may be found --> |
| <getElementsByTagName interface="Document" obj="document" tagname=""elt2"" var="elementList"/> |
| <assertSize collection="elementList" size="0" id="elt2Count_1"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterTest2.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMWriterTest2"> |
| <metadata> |
| <title>DOMWriterTest2</title> |
| &creator; |
| <description>Serializes a document without a XML declaration for both for 'xml-declaration' configuration values.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-canSetParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="configuration" type="DOMConfiguration"/> |
| <var name="XML_DECLARATION" type="DOMString" value='"xml-declaration"'/> |
| <var name="stringDoc" type="DOMString" value='"<hello>me again</hello>"'/> |
| <var name="writeResult" type="DOMString"/> |
| <var name="xmlDecl" type="DOMString"/> |
| &vars; |
| &init; |
| <!-- parse the string --> |
| <stringData obj="inputSource" value="stringDoc"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- include xml declaration on serialization --> |
| <domConfig var="configuration" obj="writer" interface="LSSerializer"/> |
| <setParameter obj="configuration" name="XML_DECLARATION" value="false"/> |
| <writeToString var="writeResult" obj="writer" nodeArg="document"/> |
| <assertEquals actual="writeResult" expected="stringDoc" id="without_xml_declaration" ignoreCase="false"/> |
| <setParameter obj="configuration" name="XML_DECLARATION" value="true"/> |
| <writeToString var="writeResult" obj="writer" nodeArg="document"/> |
| <substring var="xmlDecl" obj="writeResult" beginIndex="0" endIndex="6"/> |
| <assertEquals actual="xmlDecl" expected='"<?xml "' id="with_xml_declaration" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterTest3.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3tests.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="DOMWriterTest3"> |
| <metadata> |
| <title>DOMWriterTest3</title> |
| &creator; |
| <description>Serializes a document with a XML declaration for both for 'xml-declaration' configuration values.</description> |
| &contributor; &date; |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMConfiguration-canSetParameter"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="configuration" type="DOMConfiguration"/> |
| <var name="XML_DECLARATION" type="DOMString" value='"xml-declaration"'/> |
| <var name="stringDoc" type="DOMString" value='"<?xml version='1.0'?><hello>me again</hello>"'/> |
| <var name="writeResult" type="DOMString"/> |
| <var name="xmlDecl" type="DOMString"/> |
| &vars; |
| &init; |
| <!-- parse the string --> |
| <stringData obj="inputSource" value="stringDoc"/> |
| <parse var="document" obj="parser" input="inputSource"/> |
| <!-- include xml declaration on serialization --> |
| <domConfig var="configuration" obj="writer" interface="LSSerializer"/> |
| <setParameter obj="configuration" name="XML_DECLARATION" value="false"/> |
| <writeToString var="writeResult" obj="writer" nodeArg="document"/> |
| <assertEquals actual="writeResult" expected='"<hello>me again</hello>"' id="without_xml_declaration" ignoreCase="false"/> |
| <setParameter obj="configuration" name="XML_DECLARATION" value="true"/> |
| <writeToString var="writeResult" obj="writer" nodeArg="document"/> |
| <substring var="xmlDecl" obj="writeResult" beginIndex="0" endIndex="6"/> |
| <assertEquals actual="xmlDecl" expected='"<?xml "' id="with_xml_declaration" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterTest4.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="DOMWriterTest4"> |
| <metadata> |
| <title>DOMWriterTest4</title> |
| <creator>Curt Arnold</creator> |
| <description>Writes a document to an uninitialized LSOutput.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-write"/> |
| </metadata> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="testDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="output" type="LSOutput"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="status" type="boolean"/> |
| <load var="testDoc" href="test0" willBeModified="false"/> |
| <implementation var="domImpl"/> |
| <!-- create an LSOutput --> |
| <createLSOutput var="output" obj="domImpl"/> |
| <!-- create a serializer and write a test document --> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <assertLSException id="throw_SERIALIZE_ERR"> |
| <SERIALIZE_ERR> |
| <write var="status" obj="serializer" destination="output" nodeArg="testDoc"/> |
| </SERIALIZE_ERR> |
| </assertLSException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterTest5.xml |
|---|
| 0,0 → 1,88 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="DOMWriterTest5"> |
| <metadata> |
| <title>DOMWriterTest5</title> |
| <creator>Curt Arnold</creator> |
| <description>Creates an document containing a namespaced attribute node without |
| user-specified prefix and checks that it is serialized properly.</description> |
| <date qualifier="created">2003-12-22</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-write"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom/2003OctDec/0062.html"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="origDoc" type="Document"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="namespaceURI" type="DOMString" value='"http://www.example.com/DOMWriterTest5"'/> |
| <var name="docElem" type="Element"/> |
| <var name="outputString" type="DOMString"/> |
| <var name="input" type="LSInput"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="parser" type="LSParser"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="parsedDoc" type="Document"/> |
| <var name="docElemLocalName" type="DOMString"/> |
| <var name="docElemNS" type="DOMString"/> |
| <implementation var="domImpl"/> |
| <createDocument var="origDoc" obj="domImpl" |
| namespaceURI="namespaceURI" |
| qualifiedName='"test"' |
| doctype="nullDocType"/> |
| <documentElement var="docElem" obj="origDoc"/> |
| <setAttributeNS obj="docElem" namespaceURI="namespaceURI" qualifiedName='"attr"' value='"test value"'/> |
| <!-- create a serializer and write the document --> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <writeToString var="outputString" obj="serializer" nodeArg="origDoc"/> |
| <!-- create an LSInput --> |
| <createLSInput var="input" obj="domImpl"/> |
| <stringData obj="input" value="outputString"/> |
| <!-- create parser --> |
| <createLSParser var="parser" obj="domImpl" mode="1" schemaType="NULL_SCHEMA_TYPE"/> |
| <parse var="parsedDoc" obj="parser" input="input"/> |
| <documentElement var="docElem" obj="parsedDoc"/> |
| <!-- check local name of document element --> |
| <localName var="docElemLocalName" obj="docElem"/> |
| <assertEquals actual="docElemLocalName" expected='"test"' ignoreCase="false" id="docElemLocalName"/> |
| <!-- namespace of document element --> |
| <namespaceURI var="docElemNS" obj="docElem" interface="Node"/> |
| <assertEquals actual="docElemNS" expected="namespaceURI" ignoreCase="false" id="docElemNS"/> |
| <!-- attribute with namespaceURI namespace --> |
| <getAttributeNS var="attrValue" obj="docElem" namespaceURI="namespaceURI" localName='"attr"'/> |
| <assertEquals actual="attrValue" expected='"test value"' ignoreCase="false" id="properNSAttrValue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/DOMWriterTest6.xml |
|---|
| 0,0 → 1,89 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="DOMWriterTest6"> |
| <metadata> |
| <title>DOMWriterTest6</title> |
| <creator>Curt Arnold</creator> |
| <description>Creates an document containing a namespaced attribute node with |
| user-specified prefix and checks that it is serialized properly.</description> |
| <date qualifier="created">2003-12-22</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-write"/> |
| <subject resource="http://lists.w3.org/Archives/Public/www-dom/2003OctDec/0062.html"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="origDoc" type="Document"/> |
| <var name="nullDocType" type="DocumentType" isNull="true"/> |
| <var name="namespaceURI" type="DOMString" value='"http://www.example.com/DOMWriterTest5"'/> |
| <var name="docElem" type="Element"/> |
| <var name="outputString" type="DOMString"/> |
| <var name="input" type="LSInput"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="parser" type="LSParser"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="parsedDoc" type="Document"/> |
| <var name="docElemLocalName" type="DOMString"/> |
| <var name="docElemNS" type="DOMString"/> |
| <implementation var="domImpl"/> |
| <createDocument var="origDoc" obj="domImpl" |
| namespaceURI="namespaceURI" |
| qualifiedName='"test"' |
| doctype="nullDocType"/> |
| <documentElement var="docElem" obj="origDoc"/> |
| <setAttributeNS obj="docElem" namespaceURI="namespaceURI" qualifiedName='"test:attr"' value='"test value"'/> |
| <!-- create a serializer and write the document --> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <writeToString var="outputString" obj="serializer" nodeArg="origDoc"/> |
| <!-- create an LSInput --> |
| <createLSInput var="input" obj="domImpl"/> |
| <stringData obj="input" value="outputString"/> |
| <!-- create parser --> |
| <createLSParser var="parser" obj="domImpl" mode="1" schemaType="NULL_SCHEMA_TYPE"/> |
| <parse var="parsedDoc" obj="parser" input="input"/> |
| <documentElement var="docElem" obj="parsedDoc"/> |
| <!-- check local name of document element --> |
| <localName var="docElemLocalName" obj="docElem"/> |
| <assertEquals actual="docElemLocalName" expected='"test"' ignoreCase="false" id="docElemLocalName"/> |
| <!-- namespace of document element --> |
| <namespaceURI var="docElemNS" obj="docElem" interface="Node"/> |
| <assertEquals actual="docElemNS" expected="namespaceURI" ignoreCase="false" id="docElemNS"/> |
| <!-- attribute with namespaceURI namespace --> |
| <getAttributeNS var="attrValue" obj="docElem" namespaceURI="namespaceURI" localName='"attr"'/> |
| <assertEquals actual="attrValue" expected='"test value"' ignoreCase="false" id="properNSAttrValue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/GetFeature1.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="GetFeature1"> |
| <metadata> |
| <title>GetFeature1</title> |
| <creator>Curt Arnold</creator> |
| <description>DOMImplementationLS can be obtained by DOMImplementation.getFeature("LS", "3.0").</description> |
| <date qualifier="created">2003-12-09</date> |
| <!-- DOMImplementation.getFeature --> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMImplementation3-getFeature"/> |
| </metadata> |
| <hasFeature feature='"Core"' version='"3.0"'/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="output" type="LSOutput"/> |
| <implementation var="domImpl"/> |
| <getFeature var="domImplLS" obj="domImpl" |
| feature='"LS"' version='"3.0"' interface="DOMImplementation"/> |
| <assertNotNull actual="domImplLS" id="domImplLSNotNull"/> |
| <createLSOutput var="output" obj="domImplLS"/> |
| <assertNotNull actual="output" id="outputNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/GetFeature2.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="GetFeature2"> |
| <metadata> |
| <title>GetFeature2</title> |
| <creator>Curt Arnold</creator> |
| <description>DOMImplementationLS can be obtained by DOMImplementation.getFeature("+lS", "3.0").</description> |
| <date qualifier="created">2003-12-09</date> |
| <!-- DOMImplementation.getFeature --> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#DOMImplementation3-getFeature"/> |
| </metadata> |
| <hasFeature feature='"Core"' version='"3.0"'/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="output" type="LSOutput"/> |
| <implementation var="domImpl"/> |
| <getFeature var="domImplLS" obj="domImpl" feature='"+lS"' |
| version='"3.0"' interface="DOMImplementation"/> |
| <assertNotNull actual="domImplLS" id="domImplLSNotNull"/> |
| <createLSOutput var="output" obj="domImplLS"/> |
| <assertNotNull actual="output" id="outputNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/HasFeature01.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="HasFeature01"> |
| <metadata> |
| <title>HasFeature01</title> |
| <creator>Curt Arnold</creator> |
| <description>Implementations should return true for hasFeature("LS", "3.0").</description> |
| <date qualifier="created">2003-12-01</date> |
| <!-- DOMImplementation.hasFeature --> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasLS" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature var="hasLS" obj="domImpl" feature='"LS"' version='"3.0"'/> |
| <assertTrue actual="hasLS" id="hasFeature_LS3"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/HasFeature02.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="HasFeature02"> |
| <metadata> |
| <title>HasFeature02</title> |
| <creator>Curt Arnold</creator> |
| <description>Implementations should return true for hasFeature("LS", null).</description> |
| <date qualifier="created">2003-12-01</date> |
| <!-- DOMImplementation.hasFeature --> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasLS" type="boolean"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <implementation var="domImpl"/> |
| <hasFeature var="hasLS" obj="domImpl" feature='"LS"' version="version"/> |
| <assertTrue actual="hasLS" id="hasFeature_LS"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/HasFeature03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="HasFeature03"> |
| <metadata> |
| <title>HasFeature03</title> |
| <creator>Curt Arnold</creator> |
| <description>Implementations should return true for hasFeature("Core", "2.0") and hasFeature("Core", null).</description> |
| <date qualifier="created">2003-12-01</date> |
| <!-- DOMImplementation.hasFeature --> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasLS" type="boolean"/> |
| <var name="NULL_VERSION" type="DOMString" isNull="true"/> |
| <implementation var="domImpl"/> |
| <hasFeature var="hasLS" obj="domImpl" feature='"cOrE"' version='"2.0"'/> |
| <assertTrue actual="hasLS" id="hasFeature_Core2"/> |
| <hasFeature var="hasLS" obj="domImpl" feature='"cOrE"' version="NULL_VERSION"/> |
| <assertTrue actual="hasLS" id="hasFeature_Core"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/HasFeature04.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="HasFeature04"> |
| <metadata> |
| <title>HasFeature04</title> |
| <creator>Curt Arnold</creator> |
| <description>Implementations should return true for hasFeature("+lS", "3.0").</description> |
| <date qualifier="created">2003-12-09</date> |
| <!-- DOMImplementation.hasFeature --> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-5CED94D7"/> |
| </metadata> |
| <!-- + on feature names requires L3 Core --> |
| <hasFeature feature='"Core"' version='"3.0"'/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasLS" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature var="hasLS" obj="domImpl" feature='"+lS"' version='"3.0"'/> |
| <assertTrue actual="hasLS" id="hasFeature_LS3"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/HasFeature05.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="HasFeature05"> |
| <metadata> |
| <title>HasFeature05</title> |
| <creator>Curt Arnold</creator> |
| <description>The return values of hasFeature("lS-aSynC", "3.0") and hasFeature("+Ls-AsYNc", "3.0") should be equal.</description> |
| <date qualifier="created">2003-12-09</date> |
| <!-- DOMImplementation.hasFeature --> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#ID-5CED94D7"/> |
| </metadata> |
| <!-- + on feature names requires L3 Core --> |
| <hasFeature feature='"Core"' version='"3.0"'/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasLS1" type="boolean"/> |
| <var name="hasLS2" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature var="hasLS1" obj="domImpl" feature='"lS-aSynC"' version='"3.0"'/> |
| <hasFeature var="hasLS2" obj="domImpl" feature='"+Ls-AsYNc"' version='"3.0"'/> |
| <assertEquals actual="hasLS2" expected="hasLS1" id="featuresEqual" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSParserConfig1.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSParserConfig1"> |
| <metadata> |
| <title>LSParserConfig1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks initial state of parser configuration.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="resolver" type="LSResourceResolver"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <domConfig var="config" obj="parser" interface="LSParser"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name='"cHarset-overrides-xml-encoding"'/> |
| <assertTrue actual="state" id="charset-overrides-xml-encoding-is-true"/> |
| <getParameter var="state" obj="config" name='"dIsallow-doctype"'/> |
| <assertFalse actual="state" id="disallow-doctype-is-false"/> |
| <getParameter var="state" obj="config" name='"iGnore-unknown-character-denormalizations"'/> |
| <assertTrue actual="state" id="ignore-unknown-character-denormalizations-is-true"/> |
| <getParameter var="state" obj="config" name='"iNfoset"'/> |
| <assertTrue actual="state" id="infoset-is-true"/> |
| <getParameter var="state" obj="config" name='"nAmespaces"'/> |
| <assertTrue actual="state" id="namespaces-is-true"/> |
| <getParameter var="resolver" obj="config" name='"rEsource-resolver"'/> |
| <assertNull actual="resolver" id="resource-resolver-is-null"/> |
| <getParameter var="state" obj="config" name='"sUpported-media-types-only"'/> |
| <assertFalse actual="state" id="supported-media-types-only-is-false"/> |
| <getParameter var="state" obj="config" name='"wEll-formed"'/> |
| <assertTrue actual="state" id="well-formed-is-true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSParserConfig2.xml |
|---|
| 0,0 → 1,88 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSParserConfig2"> |
| <metadata> |
| <title>LSParserConfig2</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks getParameterNames and canSetParameter.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="resolver" type="LSResourceResolver"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <var name="parameterNames" type="DOMStringList"/> |
| <var name="parameterName" type="DOMString"/> |
| <var name="matchCount" type="int" value="0"/> |
| <var name="paramValue" type="DOMUserData"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <domConfig var="config" obj="parser" interface="LSParser"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <parameterNames var="parameterNames" obj="config"/> |
| <assertNotNull actual="parameterNames" id="parameterNamesNotNull"/> |
| <for-each collection="parameterNames" member="parameterName"> |
| <!-- get the default value of this parameter --> |
| <getParameter var="paramValue" obj="config" name="parameterName"/> |
| <!-- should be able to set to default value --> |
| <canSetParameter var="canSet" obj="config" name="parameterName" value="paramValue"/> |
| <assertTrue actual="canSet" id="canSetToDefaultValue"/> |
| <setParameter obj="config" name="parameterName" value="paramValue"/> |
| <if> |
| <or> |
| <equals actual="parameterName" expected='"canonical-form"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"cdata-sections"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"check-character-normalization"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"comments"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"datatype-normalization"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"entities"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"error-handler"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"infoset"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"namespaces"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"namespace-declarations"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"normalize-characters"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"schema-location"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"schema-type"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"split-cdata-sections"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"validate"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"validate-if-schema"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"well-formed"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"element-content-whitespace"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"charset-overrides-xml-encoding"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"disallow-doctype"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"ignore-unknown-character-denormalizations"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"resource-resolver"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"supported-media-types-only"' ignoreCase="true"/> |
| </or> |
| <increment var="matchCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="matchCount" expected="23" id="definedParameterCount" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSParserConfig3.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSParserConfig3"> |
| <metadata> |
| <title>LSParserConfig3</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of charset-overrides-xml-encoding.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <var name="propertyName" type="DOMString" value='"cHarset-overrides-xml-encoding"'/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <domConfig var="config" obj="parser" interface="LSParser"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalse"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSParserConfig4.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSParserConfig4"> |
| <metadata> |
| <title>LSParserConfig4</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of disallow-doctype.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"dIsAllow-doctype"'/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" mode="1" schemaType="NULL_SCHEMA_TYPE"/> |
| <domConfig var="config" obj="parser" interface="LSParser"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrueIsEffective"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalseIsEffective"/> |
| <else> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_if_canSetParameter_false"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSParserConfig5.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSParserConfig5"> |
| <metadata> |
| <title>LSParserConfig5</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of ignore-unknown-character-denormalizations.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"iGnOre-unknown-character-denormalizations"'/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" mode="1" schemaType="NULL_SCHEMA_TYPE"/> |
| <domConfig var="config" obj="parser" interface="LSParser"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalseIsEffective"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setTrueIsEffective"/> |
| <else> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_if_not_canSetParameter"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSParserConfig6.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSParserConfig6"> |
| <metadata> |
| <title>LSParserConfig6</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of infoset.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <var name="propertyName" type="DOMString" value='"iNfoset"'/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <domConfig var="config" obj="parser" interface="LSParser"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <!-- setting infoset to false should have no effect |
| that is infoset will still be true --> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setFalse"/> |
| <!-- setting comments to false should change value of |
| infoset to false --> |
| <setParameter obj="config" name='"comments"' value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="falseWhenCommentsFalse"/> |
| <!-- setting infoset to true should cause infoset to be true |
| and comments to be true --> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="resetTrue"/> |
| <getParameter var="state" obj="config" name='"comments"'/> |
| <assertTrue actual="state" id="resetTrueComments"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSParserConfig7.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSParserConfig7"> |
| <metadata> |
| <title>LSParserConfig7</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of namespaces.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"nAmespaces"'/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" mode="1" schemaType="NULL_SCHEMA_TYPE"/> |
| <domConfig var="config" obj="parser" interface="LSParser"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalseIsEffective"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrueIsEffective"/> |
| <else> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_if_not_canSetParameter"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSParserConfig8.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSParserConfig8"> |
| <metadata> |
| <title>LSParserConfig8</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of well-formed.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <var name="propertyName" type="DOMString" value='"wEll-formed"'/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" mode="1" schemaType="NULL_SCHEMA_TYPE"/> |
| <domConfig var="config" obj="parser" interface="LSParser"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <assertFalse actual="canSet" id="canSetFalse"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_EXCEPTION"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSParserConfig9.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSParserConfig9"> |
| <metadata> |
| <title>LSParserConfig9</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of supported-media-types-only.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="parser" type="LSParser"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"sUpported-media-types-only"'/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <implementation var="domImpl"/> |
| <createLSParser var="parser" obj="domImpl" mode="1" schemaType="NULL_SCHEMA_TYPE"/> |
| <domConfig var="config" obj="parser" interface="LSParser"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrueIsEffective"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalseIsEffective"/> |
| <else> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_if_canSetParameter_false"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSSerializerConfig1.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSSerializerConfig1"> |
| <metadata> |
| <title>LSSerializerConfig1</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks initial state of serializer configuration.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImpl"/> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <domConfig var="config" obj="serializer" interface="LSSerializer"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name='"cAnonical-form"'/> |
| <assertFalse actual="state" id="canonical-form-is-false"/> |
| <getParameter var="state" obj="config" name='"dIscard-default-content"'/> |
| <assertTrue actual="state" id="discard-default-content-is-true"/> |
| <getParameter var="state" obj="config" name='"fOrmat-pretty-print"'/> |
| <assertFalse actual="state" id="format-pretty-print-is-false"/> |
| <getParameter var="state" obj="config" name='"iGnore-unknown-character-denormalizations"'/> |
| <assertTrue actual="state" id="ignore-unknown-character-denormalizations-is-true"/> |
| <!-- normalize characters is supposed to be true if |
| the implementation supports true --> |
| <getParameter var="state" obj="config" name='"nOrmalize-characters"'/> |
| <canSetParameter var="canSet" obj="config" name='"normalize-characters"' value="true"/> |
| <assertTrue id="normalize-characters-default"> |
| <or> |
| <isTrue value="state"/> |
| <isFalse value="canSet"/> |
| </or> |
| </assertTrue> |
| <getParameter var="state" obj="config" name='"xMl-declaration"'/> |
| <assertTrue actual="state" id="xml-declaration-is-true"/> |
| <getParameter var="state" obj="config" name='"wEll-formed"'/> |
| <assertTrue actual="state" id="well-formed-is-true"/> |
| <getParameter var="state" obj="config" name='"nAmespaces"'/> |
| <assertTrue actual="state" id="namespaces-is-true"/> |
| <getParameter var="state" obj="config" name='"nAmespace-declarations"'/> |
| <assertTrue actual="state" id="namespace-declarations-is-true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSSerializerConfig10.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSSerializerConfig10"> |
| <metadata> |
| <title>LSSerializerConfig10</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of namespace-declarations.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"nAmespace-declarations"'/> |
| <implementation var="domImpl"/> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <domConfig var="config" obj="serializer" interface="LSSerializer"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalseIsEffective"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrueIsEffective"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSSerializerConfig2.xml |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSSerializerConfig2"> |
| <metadata> |
| <title>LSSerializerConfig2</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks getParameterNames and canSetParameter.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="parameterNames" type="DOMStringList"/> |
| <var name="parameterName" type="DOMString"/> |
| <var name="matchCount" type="int" value="0"/> |
| <var name="paramValue" type="DOMUserData"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImpl"/> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <domConfig var="config" obj="serializer" interface="LSSerializer"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <parameterNames var="parameterNames" obj="config"/> |
| <assertNotNull actual="parameterNames" id="parameterNamesNotNull"/> |
| <for-each collection="parameterNames" member="parameterName"> |
| <!-- get the default value of this parameter --> |
| <getParameter var="paramValue" obj="config" name="parameterName"/> |
| <!-- should be able to set to default value --> |
| <canSetParameter var="canSet" obj="config" name="parameterName" value="paramValue"/> |
| <assertTrue actual="canSet" id="canSetToDefaultValue"/> |
| <setParameter obj="config" name="parameterName" value="paramValue"/> |
| <if> |
| <or> |
| <equals actual="parameterName" expected='"canonical-form"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"cdata-sections"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"check-character-normalization"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"comments"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"datatype-normalization"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"entities"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"error-handler"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"infoset"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"namespaces"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"namespace-declarations"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"normalize-characters"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"split-cdata-sections"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"validate"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"validate-if-schema"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"well-formed"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"element-content-whitespace"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"discard-default-content"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"format-pretty-print"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"ignore-unknown-character-denormalizations"' ignoreCase="true"/> |
| <equals actual="parameterName" expected='"xml-declaration"' ignoreCase="true"/> |
| </or> |
| <increment var="matchCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="matchCount" expected="20" id="definedParameterCount" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSSerializerConfig3.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSSerializerConfig3"> |
| <metadata> |
| <title>LSSerializerConfig3</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of canonical-form.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"cAnonical-form"'/> |
| <implementation var="domImpl"/> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <domConfig var="config" obj="serializer" interface="LSSerializer"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrueIsEffective"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalseIsEffective"/> |
| <else> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_if_canSetParameter_false"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSSerializerConfig4.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSSerializerConfig4"> |
| <metadata> |
| <title>LSSerializerConfig4</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of discard-default-content.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"dIscard-default-content"'/> |
| <implementation var="domImpl"/> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <domConfig var="config" obj="serializer" interface="LSSerializer"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalse"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSSerializerConfig5.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSSerializerConfig5"> |
| <metadata> |
| <title>LSSerializerConfig5</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of format-pretty-print.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"fOrmat-pretty-print"'/> |
| <implementation var="domImpl"/> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <domConfig var="config" obj="serializer" interface="LSSerializer"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrueIsEffective"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalseIsEffective"/> |
| <else> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_if_canSetParameter_false"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSSerializerConfig6.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSSerializerConfig6"> |
| <metadata> |
| <title>LSSerializerConfig6</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of ignore-unknown-character-denormalizations.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"iGnore-unknown-character-denormalizations"'/> |
| <implementation var="domImpl"/> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <domConfig var="config" obj="serializer" interface="LSSerializer"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalseIsEffective"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrueIsEffective"/> |
| <else> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR_if_canSetParameter_false"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSSerializerConfig7.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSSerializerConfig7"> |
| <metadata> |
| <title>LSSerializerConfig7</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of xml-declaration.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"xMl-declaration"'/> |
| <implementation var="domImpl"/> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <domConfig var="config" obj="serializer" interface="LSSerializer"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <assertTrue actual="canSet" id="canSetFalse"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalse"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSSerializerConfig8.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSSerializerConfig8"> |
| <metadata> |
| <title>LSSerializerConfig8</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of well-formed.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"wEll-formed"'/> |
| <implementation var="domImpl"/> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <domConfig var="config" obj="serializer" interface="LSSerializer"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalseIsEffective"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrueIsEffective"/> |
| <else> |
| <assertDOMException id="throw_NOT_SUPPORTED_EXCEPTION"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/LSSerializerConfig9.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="LSSerializerConfig9"> |
| <metadata> |
| <title>LSSerializerConfig9</title> |
| <creator>Curt Arnold</creator> |
| <description>Checks support of namespaces.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-config"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="config" type="DOMConfiguration"/> |
| <var name="state" type="boolean"/> |
| <var name="canSet" type="boolean"/> |
| <var name="propertyName" type="DOMString" value='"nAmespaces"'/> |
| <implementation var="domImpl"/> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <domConfig var="config" obj="serializer" interface="LSSerializer"/> |
| <assertNotNull actual="config" id="configNotNull"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="defaultValue"/> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="true"/> |
| <assertTrue actual="canSet" id="canSetTrue"/> |
| <!-- TODO: Changed in anticipation of forthcoming spec change |
| will need to review final wording --> |
| <canSetParameter var="canSet" obj="config" name="propertyName" value="false"/> |
| <if> |
| <isTrue value="canSet"/> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertFalse actual="state" id="setFalseIsEffective"/> |
| <setParameter obj="config" name="propertyName" value="true"/> |
| <getParameter var="state" obj="config" name="propertyName"/> |
| <assertTrue actual="state" id="setTrueIsEffective"/> |
| <else> |
| <assertDOMException id="settingFalseWhenNotSupported"> |
| <NOT_SUPPORTED_ERR> |
| <setParameter obj="config" name="propertyName" value="false"/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </else> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/SystemId1.xml |
|---|
| 0,0 → 1,87 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="SystemId1"> |
| <metadata> |
| <title>SystemId1</title> |
| <creator>Curt Arnold</creator> |
| <description>Writes a document to a URL for a temporary file and rereads the document.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-systemId"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSOutput-systemId"/> |
| </metadata> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="testDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="output" type="LSOutput"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="systemId" type="DOMString"/> |
| <var name="checkSystemId" type="DOMString"/> |
| <var name="status" type="boolean"/> |
| <var name="input" type="LSInput"/> |
| <var name="parser" type="LSParser"/> |
| <var name="checkDoc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemName" type="DOMString"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <load var="testDoc" href="test0" willBeModified="false"/> |
| <implementation var="domImpl"/> |
| <!-- create an LSOutput and connect it to an stock LSWriter --> |
| <createLSOutput var="output" obj="domImpl"/> |
| <!-- check that it was initially null --> |
| <systemId var="checkSystemId" obj="output" interface="LSOutput"/> |
| <assertNull actual="checkSystemId" id="LSOutputSystemIdInitiallyNull"/> |
| <createTempURI var="systemId" scheme="file"/> |
| <systemId obj="output" value="systemId" interface="LSOutput"/> |
| <systemId var="checkSystemId" obj="output" interface="LSOutput"/> |
| <assertEquals expected="systemId" |
| actual="checkSystemId" |
| ignoreCase="false" |
| id="LSOutputSystemIdMatch"/> |
| <!-- create a serializer and write a test document --> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <write var="status" obj="serializer" destination="output" nodeArg="testDoc"/> |
| <assertTrue actual="status" id="writeStatus"/> |
| <!-- read the serialized document --> |
| <createLSInput var="input" obj="domImpl"/> |
| <systemId var="checkSystemId" obj="input" interface="LSInput"/> |
| <assertNull actual="checkSystemId" id="LSInputSystemIdInitiallyNull"/> |
| <systemId obj="input" value="systemId" interface="LSInput"/> |
| <systemId var="checkSystemId" obj="input" interface="LSInput"/> |
| <assertEquals expected="systemId" |
| actual="checkSystemId" |
| ignoreCase="false" |
| id="LSInputSystemIdMatch"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <parse var="checkDoc" obj="parser" input="input"/> |
| <assertNotNull actual="checkDoc" id="checkNotNull"/> |
| <documentElement var="docElem" obj="checkDoc"/> |
| <nodeName var="docElemName" obj="docElem"/> |
| <assertEquals expected='"elt0"' actual="docElemName" id="checkDocElemName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/SystemId2.xml |
|---|
| 0,0 → 1,87 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="SystemId2"> |
| <metadata> |
| <title>SystemId2</title> |
| <creator>Curt Arnold</creator> |
| <description>Writes a document to a URL for a temporary http document and rereads the document.</description> |
| <date qualifier="created">2003-12-08</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSInput-systemId"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSOutput-systemId"/> |
| </metadata> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="testDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="output" type="LSOutput"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="systemId" type="DOMString"/> |
| <var name="checkSystemId" type="DOMString"/> |
| <var name="status" type="boolean"/> |
| <var name="input" type="LSInput"/> |
| <var name="parser" type="LSParser"/> |
| <var name="checkDoc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemName" type="DOMString"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <load var="testDoc" href="test0" willBeModified="false"/> |
| <implementation var="domImpl"/> |
| <!-- create an LSOutput and connect it to an stock LSWriter --> |
| <createLSOutput var="output" obj="domImpl"/> |
| <!-- check that it was initially null --> |
| <systemId var="checkSystemId" obj="output" interface="LSOutput"/> |
| <assertNull actual="checkSystemId" id="LSOutputSystemIdInitiallyNull"/> |
| <createTempURI var="systemId" scheme="http"/> |
| <systemId obj="output" value="systemId" interface="LSOutput"/> |
| <systemId var="checkSystemId" obj="output" interface="LSOutput"/> |
| <assertEquals expected="systemId" |
| actual="checkSystemId" |
| ignoreCase="false" |
| id="LSOutputSystemIdMatch"/> |
| <!-- create a serializer and write a test document --> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <write var="status" obj="serializer" destination="output" nodeArg="testDoc"/> |
| <assertTrue actual="status" id="writeStatus"/> |
| <!-- read the serialized document --> |
| <createLSInput var="input" obj="domImpl"/> |
| <systemId var="checkSystemId" obj="input" interface="LSInput"/> |
| <assertNull actual="checkSystemId" id="LSInputSystemIdInitiallyNull"/> |
| <systemId obj="input" value="systemId" interface="LSInput"/> |
| <systemId var="checkSystemId" obj="input" interface="LSInput"/> |
| <assertEquals expected="systemId" |
| actual="checkSystemId" |
| ignoreCase="false" |
| id="LSInputSystemIdMatch"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <parse var="checkDoc" obj="parser" input="input"/> |
| <assertNotNull actual="checkDoc" id="checkNotNull"/> |
| <documentElement var="docElem" obj="checkDoc"/> |
| <nodeName var="docElemName" obj="docElem"/> |
| <assertEquals expected='"elt0"' actual="docElemName" id="checkDocElemName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/alltests.xml |
|---|
| 0,0 → 1,213 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 X-Hive Corporation |
| All Rights Reserved. This work is distributed under the W3C(r) |
| Software License [1] in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE suite SYSTEM "dom3.dtd"> |
| <suite xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="alltests"> |
| <metadata> |
| <title>DOM Level 3 LS Test Suite</title> |
| <creator>X-Hive Corporation</creator> |
| </metadata> |
| <suite.member href="DOMBuilderFilterTest0.xml"/> |
| <suite.member href="DOMBuilderFilterTest1.xml"/> |
| <suite.member href="DOMBuilderFilterTest2.xml"/> |
| <suite.member href="DOMBuilderTest0.xml"/> |
| <suite.member href="DOMBuilderTest1.xml"/> |
| <suite.member href="DOMBuilderTest2.xml"/> |
| <suite.member href="DOMBuilderTest3.xml"/> |
| <suite.member href="DOMBuilderTest4.xml"/> |
| <suite.member href="DOMBuilderTest5.xml"/> |
| <suite.member href="DOMBuilderTest6.xml"/> |
| <suite.member href="DOMBuilderTest8.xml"/> |
| <suite.member href="DOMEntityResolverTest0.xml"/> |
| <suite.member href="DOMEntityResolverTest1.xml"/> |
| <suite.member href="DOMEntityResolverTest2.xml"/> |
| <suite.member href="DOMImplementationLSTest0.xml"/> |
| <suite.member href="DOMImplementationLSTest1.xml"/> |
| <suite.member href="DOMImplementationLSTest2.xml"/> |
| <suite.member href="DOMImplementationLSTest3.xml"/> |
| <suite.member href="DOMImplementationLSTest4.xml"/> |
| <suite.member href="DOMImplementationLSTest5.xml"/> |
| <suite.member href="DOMInputSourceTest0.xml"/> |
| <suite.member href="DOMInputSourceTest1.xml"/> |
| <suite.member href="DOMInputSourceTest2.xml"/> |
| <suite.member href="DOMInputSourceTest3.xml"/> |
| <suite.member href="DOMInputSourceTest4.xml"/> |
| <suite.member href="DOMInputSourceTest5.xml"/> |
| <suite.member href="DOMInputSourceTest6.xml"/> |
| <suite.member href="DOMWriterFilterTest0.xml"/> |
| <suite.member href="DOMWriterFilterTest1.xml"/> |
| <suite.member href="DOMWriterFilterTest2.xml"/> |
| <suite.member href="DOMWriterFilterTest3.xml"/> |
| <suite.member href="DOMWriterTest0.xml"/> |
| <suite.member href="DOMWriterTest1.xml"/> |
| <suite.member href="DOMWriterTest2.xml"/> |
| <suite.member href="DOMWriterTest3.xml"/> |
| <suite.member href="DOMWriterTest4.xml"/> |
| <suite.member href="DOMWriterTest5.xml"/> |
| <suite.member href="DOMWriterTest6.xml"/> |
| <suite.member href="encoding01.xml"/> |
| <suite.member href="GetFeature1.xml"/> |
| <suite.member href="GetFeature2.xml"/> |
| <suite.member href="HasFeature01.xml"/> |
| <suite.member href="HasFeature02.xml"/> |
| <suite.member href="HasFeature03.xml"/> |
| <suite.member href="HasFeature04.xml"/> |
| <suite.member href="HasFeature05.xml"/> |
| <suite.member href="CharacterStream1.xml"/> |
| <suite.member href="SystemId1.xml"/> |
| <suite.member href="SystemId2.xml"/> |
| <suite.member href="CertifiedText1.xml"/> |
| <suite.member href="LSParserConfig1.xml"/> |
| <suite.member href="LSParserConfig2.xml"/> |
| <suite.member href="LSParserConfig3.xml"/> |
| <suite.member href="LSParserConfig4.xml"/> |
| <suite.member href="LSParserConfig5.xml"/> |
| <suite.member href="LSParserConfig6.xml"/> |
| <suite.member href="LSParserConfig7.xml"/> |
| <suite.member href="LSParserConfig8.xml"/> |
| <suite.member href="LSParserConfig9.xml"/> |
| <suite.member href="LSSerializerConfig1.xml"/> |
| <suite.member href="LSSerializerConfig2.xml"/> |
| <suite.member href="LSSerializerConfig3.xml"/> |
| <suite.member href="LSSerializerConfig4.xml"/> |
| <suite.member href="LSSerializerConfig5.xml"/> |
| <suite.member href="LSSerializerConfig6.xml"/> |
| <suite.member href="LSSerializerConfig7.xml"/> |
| <suite.member href="LSSerializerConfig8.xml"/> |
| <suite.member href="LSSerializerConfig9.xml"/> |
| <suite.member href="LSSerializerConfig10.xml"/> |
| <suite.member href="writeToURI1.xml"/> |
| <suite.member href="writeToURI2.xml"/> |
| <suite.member href="canonicalform01.xml"/> |
| <suite.member href="canonicalform03.xml"/> |
| <suite.member href="canonicalform04.xml"/> |
| <suite.member href="canonicalform05.xml"/> |
| <suite.member href="canonicalform06.xml"/> |
| <suite.member href="canonicalform08.xml"/> |
| <suite.member href="canonicalform09.xml"/> |
| <suite.member href="canonicalform10.xml"/> |
| <suite.member href="canonicalform11.xml"/> |
| <suite.member href="canonicalform12.xml"/> |
| <suite.member href="canonicalform13.xml"/> |
| <suite.member href="cdatasections01.xml"/> |
| <suite.member href="cdatasections02.xml"/> |
| <suite.member href="cdatasections03.xml"/> |
| <suite.member href="cdatasections04.xml"/> |
| <suite.member href="checkcharacternormalization01.xml"/> |
| <suite.member href="checkcharacternormalization02.xml"/> |
| <suite.member href="checkcharacternormalization03.xml"/> |
| <suite.member href="checkcharacternormalization04.xml"/> |
| <suite.member href="comments01.xml"/> |
| <suite.member href="comments02.xml"/> |
| <suite.member href="comments03.xml"/> |
| <suite.member href="comments04.xml"/> |
| <suite.member href="datatypenormalization01.xml"/> |
| <suite.member href="datatypenormalization02.xml"/> |
| <suite.member href="datatypenormalization03.xml"/> |
| <suite.member href="datatypenormalization04.xml"/> |
| <suite.member href="datatypenormalization05.xml"/> |
| <suite.member href="datatypenormalization06.xml"/> |
| <suite.member href="datatypenormalization07.xml"/> |
| <suite.member href="datatypenormalization08.xml"/> |
| <suite.member href="datatypenormalization09.xml"/> |
| <suite.member href="datatypenormalization10.xml"/> |
| <suite.member href="datatypenormalization11.xml"/> |
| <suite.member href="datatypenormalization12.xml"/> |
| <suite.member href="datatypenormalization13.xml"/> |
| <suite.member href="datatypenormalization14.xml"/> |
| <suite.member href="datatypenormalization15.xml"/> |
| <suite.member href="datatypenormalization16.xml"/> |
| <suite.member href="datatypenormalization17.xml"/> |
| <suite.member href="disallowdoctype01.xml"/> |
| <suite.member href="discarddefaultcontent01.xml"/> |
| <suite.member href="discarddefaultcontent02.xml"/> |
| <suite.member href="elementcontentwhitespace01.xml"/> |
| <suite.member href="elementcontentwhitespace02.xml"/> |
| <suite.member href="elementcontentwhitespace03.xml"/> |
| <suite.member href="entities01.xml"/> |
| <suite.member href="entities02.xml"/> |
| <suite.member href="entities03.xml"/> |
| <suite.member href="entities04.xml"/> |
| <suite.member href="entities05.xml"/> |
| <suite.member href="entities06.xml"/> |
| <suite.member href="entities07.xml"/> |
| <suite.member href="entities08.xml"/> |
| <suite.member href="entities09.xml"/> |
| <suite.member href="infoset01.xml"/> |
| <suite.member href="infoset02.xml"/> |
| <suite.member href="infoset03.xml"/> |
| <suite.member href="infoset04.xml"/> |
| <suite.member href="infoset05.xml"/> |
| <suite.member href="infoset06.xml"/> |
| <suite.member href="infoset07.xml"/> |
| <suite.member href="infoset08.xml"/> |
| <suite.member href="namespacedeclarations01.xml"/> |
| <suite.member href="namespacedeclarations02.xml"/> |
| <suite.member href="namespaces01.xml"/> |
| <suite.member href="namespaces02.xml"/> |
| <suite.member href="newline01.xml"/> |
| <suite.member href="newline02.xml"/> |
| <suite.member href="newline03.xml"/> |
| <suite.member href="noinputspecified01.xml"/> |
| <suite.member href="nooutputspecified01.xml"/> |
| <suite.member href="normalizecharacters01.xml"/> |
| <suite.member href="normalizecharacters02.xml"/> |
| <suite.member href="normalizecharacters03.xml"/> |
| <suite.member href="normalizecharacters04.xml"/> |
| <suite.member href="schemalocation01.xml"/> |
| <suite.member href="schemalocation02.xml"/> |
| <suite.member href="schemalocation03.xml"/> |
| <suite.member href="schemalocation04.xml"/> |
| <suite.member href="schematype01.xml"/> |
| <suite.member href="schematype02.xml"/> |
| <suite.member href="schematype03.xml"/> |
| <suite.member href="schematype04.xml"/> |
| <suite.member href="splitcdatasections01.xml"/> |
| <suite.member href="splitcdatasections02.xml"/> |
| <suite.member href="unsupportedencoding01.xml"/> |
| <suite.member href="validate01.xml"/> |
| <suite.member href="validate02.xml"/> |
| <suite.member href="validate03.xml"/> |
| <suite.member href="validate04.xml"/> |
| <suite.member href="validate05.xml"/> |
| <suite.member href="validate06.xml"/> |
| <suite.member href="validate07.xml"/> |
| <suite.member href="validate08.xml"/> |
| <suite.member href="validateifschema01.xml"/> |
| <suite.member href="validateifschema02.xml"/> |
| <suite.member href="validateifschema03.xml"/> |
| <suite.member href="validateifschema04.xml"/> |
| <suite.member href="wellformed01.xml"/> |
| <suite.member href="wellformed02.xml"/> |
| <suite.member href="wellformed03.xml"/> |
| <suite.member href="xmldeclaration01.xml"/> |
| <suite.member href="xmldeclaration02.xml"/> |
| </suite> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform01.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform01"> |
| <metadata> |
| <title>canonicalform01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with canonical-form = true and see that entity references are not present in |
| the element content. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="1" interface="NodeList"/> |
| <firstChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="acrContentIsText"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform03.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform03"> |
| <metadata> |
| <title>canonicalform03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with canonical-form = true and see that CDATASection are not present in |
| the parsed document. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="pList" index="1" interface="NodeList"/> |
| <lastChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="childIsText"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform04.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform04"> |
| <metadata> |
| <title>canonicalform04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to load a namespace invalid document with canonical-form = true. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <getResourceURI var="resourceURI" href='"namespaces1"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform05.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform05"> |
| <metadata> |
| <title>canonicalform05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with canonical-form = true and see that attributes for namespace declarations are present. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespace-declarations"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="canSet" type="boolean"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="node" obj="elem" name='"xmlns:dmstc"'/> |
| <assertNotNull actual="node" id="nsAttrNotNull"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform06.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform06"> |
| <metadata> |
| <title>canonicalform06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with canonical-form and validate = true and check that |
| element content whitespace is not eliminated. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetCanonicalForm" type="boolean"/> |
| <var name="elemList" type="NodeList"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetCanonicalForm" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><and><isTrue value="canSetValidate"/><isTrue value="canSetCanonicalForm"/></and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <firstChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="nodeIsText"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform08.xml |
|---|
| 0,0 → 1,113 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform08"> |
| <metadata> |
| <title>canonicalform08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document based on section 3.1 with canonical-form set to true and check normalized document. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="body" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="length" type="int"/> |
| <var name="text" type="Text"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetCanonicalForm" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetCanonicalForm" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSetCanonicalForm"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <getResourceURI var="resourceURI" href='"canonicalform01"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <firstChild var="node" obj="doc" interface="Node"/> |
| <nodeType var="nodeType" obj="node" interface="Node"/> |
| <assertEquals expected="7" actual="nodeType" ignoreCase="false" id="PIisFirstChild"/> |
| <data var="nodeValue" obj="node" interface="ProcessingInstruction"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="36" ignoreCase="false" id="piDataLength"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisSecondChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="secondChildLength"/> |
| <!-- next sibling is document element --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="1" actual="nodeType" ignoreCase="false" id="ElementisThirdChild"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisFourthChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="fourthChildLength"/> |
| <!-- next sibling is a processing instruction --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="7" actual="nodeType" ignoreCase="false" id="PIisFifthChild"/> |
| <data var="nodeValue" obj="node" interface="ProcessingInstruction"/> |
| <assertEquals actual="nodeValue" expected='""' ignoreCase="false" id="trailingPIData"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisSixthChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="sixthChildLength"/> |
| <!-- next sibling is a comment --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="8" actual="nodeType" ignoreCase="false" id="CommentisSeventhChild"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisEighthChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="eighthChildLength"/> |
| <!-- next sibling is a comment --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="8" actual="nodeType" ignoreCase="false" id="CommentisNinthChild"/> |
| <!-- next sibling is a null --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <assertNull actual="node" id="TenthIsNull"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform09.xml |
|---|
| 0,0 → 1,93 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform09"> |
| <metadata> |
| <title>canonicalform09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document based on section 3.1 with canonical-form set to true |
| and comments to false and check normalized document. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="bodyList" type="NodeList"/> |
| <var name="body" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="canSet" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="nodeValue" type="DOMString"/> |
| <var name="nodeType" type="int"/> |
| <var name="length" type="int"/> |
| <var name="text" type="Text"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetCanonicalForm" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetCanonicalForm" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSetCanonicalForm"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <setParameter obj="domConfig" name='"comments"' value="false"/> |
| <getResourceURI var="resourceURI" href='"canonicalform01"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <firstChild var="node" obj="doc" interface="Node"/> |
| <nodeType var="nodeType" obj="node" interface="Node"/> |
| <assertEquals expected="7" actual="nodeType" ignoreCase="false" id="PIisFirstChild"/> |
| <data var="nodeValue" obj="node" interface="ProcessingInstruction"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="36" ignoreCase="false" id="piDataLength"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisSecondChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="secondChildLength"/> |
| <!-- next sibling is document element --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="1" actual="nodeType" ignoreCase="false" id="ElementisThirdChild"/> |
| <!-- next sibling is a #0A line feed --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="3" actual="nodeType" ignoreCase="false" id="TextisFourthChild"/> |
| <nodeValue var="nodeValue" obj="node"/> |
| <length var="length" obj="nodeValue" interface="DOMString"/> |
| <assertEquals actual="length" expected="1" ignoreCase="false" id="fourthChildLength"/> |
| <!-- next sibling is a processing instruction --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals expected="7" actual="nodeType" ignoreCase="false" id="PIisFifthChild"/> |
| <data var="nodeValue" obj="node" interface="ProcessingInstruction"/> |
| <assertEquals actual="nodeValue" expected='""' ignoreCase="false" id="trailingPIData"/> |
| <!-- next sibling is a null --> |
| <nextSibling interface="Node" var="node" obj="node"/> |
| <assertNull actual="node" id="SixthIsNull"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform10.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform10"> |
| <metadata> |
| <title>canonicalform10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check elimination of unnecessary namespace prefixes when |
| normalized with canonical-form = true. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="divList" type="NodeList"/> |
| <var name="div" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="node" type="Node"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetCanonicalForm" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetCanonicalForm" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSetCanonicalForm"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <getResourceURI var="resourceURI" href='"canonicalform03"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="divList" obj="doc" |
| tagname='"div"' interface="Document"/> |
| <item var="div" obj="divList" index="5" interface="NodeList"/> |
| <getAttributeNode var="node" obj="div" name='"xmlns"'/> |
| <assertNotNull actual="node" id="xmlnsPresent"/> |
| <getAttributeNode var="node" obj="div" name='"xmlns:a"'/> |
| <assertNull actual="node" id="xmlnsANotPresent"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform11.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform11"> |
| <metadata> |
| <title>canonicalform11</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Check that default attributes are made explicitly specified. |
| </description> |
| <date qualifier="created">2004-02-26</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="attr" type="Attr"/> |
| <var name="attrValue" type="DOMString"/> |
| <var name="attrSpecified" type="boolean"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetCanonicalForm" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetCanonicalForm" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSetCanonicalForm"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <getResourceURI var="resourceURI" href='"canonicalform03"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" |
| tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="attr" obj="elem" name='"title"'/> |
| <assertNotNull actual="attr" id="titlePresent"/> |
| <specified var="attrSpecified" obj="attr"/> |
| <assertTrue actual="attrSpecified" id="titleSpecified"/> |
| <nodeValue var="attrValue" obj="attr"/> |
| <assertEquals actual="attrValue" expected='"default"' ignoreCase="false" |
| id="titleValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform12.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform12"> |
| <metadata> |
| <title>canonicalform12</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with canonical-form = true and see that the DocumentType node is eliminated. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="doctype" type="DocumentType"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"canonical-form"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <doctype var="doctype" obj="doc"/> |
| <assertNull actual="doctype" id="doctypeIsNull"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/canonicalform13.xml |
|---|
| 0,0 → 1,61 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canonicalform13"> |
| <metadata> |
| <title>canonicalform13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Serializing an XML 1.1 document when canonical-form raises a SERIALIZE_ERR. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-canonical-form"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="output" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"canonical-form"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='""' value="true"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <try> |
| <xmlVersion obj="doc" value='"1.1"' interface="Document"/> |
| <catch> |
| <DOMException code="NOT_SUPPORTED_ERR"> |
| <return/> |
| </DOMException> |
| </catch> |
| </try> |
| <assertLSException id="throw_SERIALIZE_ERR"> |
| <SERIALIZE_ERR> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </SERIALIZE_ERR> |
| </assertLSException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/cdatasections01.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="cdatasections01"> |
| <metadata> |
| <title>cdatasections01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with cdata-sections = false and see that CDATASection are not present in |
| the parsed document. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-cdata-sections"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="false"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="pList" index="1" interface="NodeList"/> |
| <lastChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="childIsText"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/cdatasections02.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="cdatasections02"> |
| <metadata> |
| <title>cdatasections02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with cdata-sections = true and see that CDATASection are present in |
| the parsed document. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-cdata-sections"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="pList" index="1" interface="NodeList"/> |
| <lastChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="4" ignoreCase="false" id="childIsCDATA"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/cdatasections03.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="cdatasections03"> |
| <metadata> |
| <title>cdatasections03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| CDATASections should be preserved when cdata-sections is true. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-cdata-sections"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createCDATASection var="newNode" obj="doc" data='"foo"'/> |
| <appendChild var="retNode" obj="docElem" newChild="newNode"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="true"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertTrue id="containsCDATA"><contains obj="output" str='"![CDATA[foo]]"' interface="DOMString"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/cdatasections04.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="cdatasections04"> |
| <metadata> |
| <title>cdatasections04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| CDATASections should be eliminated when cdata-sections is false. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-cdata-sections"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createCDATASection var="newNode" obj="doc" data='"foo"'/> |
| <appendChild var="retNode" obj="docElem" newChild="newNode"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="false"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertTrue id="containsCDATA"><contains obj="output" str='">foo</"' interface="DOMString"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/checkcharacternormalization01.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="checkcharacternormalization01"> |
| <metadata> |
| <title>checkcharacternormalization01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parsing a non-Unicode normalized document should not raise an exception if check-character-normalization |
| is false. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-check-character-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="nullSchemaLanguage" type="DOMString" isNull="true"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaLanguage"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"check-character-normalization"' value="false"/> |
| <getResourceURI var="resourceURI" href='"characternormalization1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/checkcharacternormalization02.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="checkcharacternormalization02"> |
| <metadata> |
| <title>checkcharacternormalization02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parsing a non-Unicode normalized document should raise PARSE_ERR if check-character-normalization |
| is false. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-check-character-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="nullSchemaLanguage" type="DOMString" isNull="true"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="errorCount" type="int" value="0"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaLanguage"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"check-character-normalization"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"check-character-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"characternormalization1"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <if><greater actual="severity" expected="1"/> |
| <assertEquals actual="severity" expected="2" id="isError" ignoreCase="false"/> |
| <assertEquals actual="type" expected='"check-character-normalization-failure"' id="isCheck_Failure" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneError"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/checkcharacternormalization03.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="checkcharacternormalization03"> |
| <metadata> |
| <title>checkcharacternormalization03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Characters should not be checked for normalization on serialization if check-character-normalization = false. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-check-character-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"suçon"' doctype="docType"/> |
| <documentElement var="docElem" obj="doc"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"check-character-normalization"' value="false"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="false"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/checkcharacternormalization04.xml |
|---|
| 0,0 → 1,75 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="checkcharacternormalization04"> |
| <metadata> |
| <title>checkcharacternormalization04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Characters should be checked for normalization on serialization if check-character-normalization = true. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-check-character-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errorCount" type="int" value="0"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"suçon"' doctype="docType"/> |
| <documentElement var="docElem" obj="doc"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"check-character-normalization"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"check-character-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <assertLSException id="throw_SERIALIZE_ERR"> |
| <SERIALIZE_ERR> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </SERIALIZE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <if><equals actual="type" expected='"check-character-normalization-failure"' ignoreCase="false"/> |
| <assertEquals actual="severity" expected="2" ignoreCase="false" id="severityError"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertTrue id="hasErrors"><greater actual="errorCount" expected="0"/></assertTrue> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/comments01.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="comments01"> |
| <metadata> |
| <title>comments01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with comments = false and see that comments are not present in |
| the parsed document. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-comments"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"comments"' value="false"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <documentElement var="docElem" obj="doc"/> |
| <previousSibling var="node" obj="docElem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="10" ignoreCase="false" id="nodeIsDocType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/comments02.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="comments02"> |
| <metadata> |
| <title>comments02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with comments = true and see that comments are present in |
| the parsed document. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-comments"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"comments"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <documentElement var="docElem" obj="doc"/> |
| <previousSibling var="node" obj="docElem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="8" ignoreCase="false" id="nodeIsDocType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/comments03.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="comments03"> |
| <metadata> |
| <title>comments03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Comments should be preserved when comments is true. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-comments"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createComment var="newNode" obj="doc" data='"foo"'/> |
| <appendChild var="retNode" obj="docElem" newChild="newNode"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"comments"' value="true"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertTrue id="hasComment"><contains obj="output" str='"><!--foo--></"' interface="DOMString"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/comments04.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="comments04"> |
| <metadata> |
| <title>comments04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Comments should be discarded when comments is false. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-comments"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createComment var="newNode" obj="doc" data='"foo"'/> |
| <appendChild var="retNode" obj="docElem" newChild="newNode"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"comments"' value="false"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertFalse id="noComment"><contains obj="output" str='"<!--"' interface="DOMString"/></assertFalse> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization01.xml |
|---|
| 0,0 → 1,93 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization01"> |
| <metadata> |
| <title>datatypenormalization01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if double values were normalized. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"double"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"+0003.141592600E+0000"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"+0003.141592600E+0000"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"-31415926.00E-7 2.718"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"NaN"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"NaN"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"INF -INF"' ignoreCase="false" id="secondList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"1"' ignoreCase="false" id="thirdValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"1"' ignoreCase="false" id="thirdUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"-0"' ignoreCase="false" id="thirdList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization02.xml |
|---|
| 0,0 → 1,86 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization02"> |
| <metadata> |
| <title>datatypenormalization02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if decimal values were normalized. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"decimal"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"+0003.141592600"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"+0003.141592600"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"+10 .1"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"01"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"01"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"-.001"' ignoreCase="false" id="secondList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization03.xml |
|---|
| 0,0 → 1,86 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization03"> |
| <metadata> |
| <title>datatypenormalization03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if boolean values were whitespace normalized. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"boolean"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"true"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"false"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"false true false"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"1"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"0"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"0 1 0"' ignoreCase="false" id="secondList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization04.xml |
|---|
| 0,0 → 1,93 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization04"> |
| <metadata> |
| <title>datatypenormalization04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if float values were normalized. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"float"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"+0003.141592600E+0000"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"+0003.141592600E+0000"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"-31415926.00E-7 2.718"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"NaN"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"NaN"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"INF -INF"' ignoreCase="false" id="secondList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"1"' ignoreCase="false" id="thirdValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"1"' ignoreCase="false" id="thirdUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"-0"' ignoreCase="false" id="thirdList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization05.xml |
|---|
| 0,0 → 1,93 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization05"> |
| <metadata> |
| <title>datatypenormalization05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if dateTime values were correctly normalized. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"dateTime"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00-05:00"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"2004-01-21T20:30:00-05:00"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00 2004-01-21T15:30:00Z"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0000-05:00"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0000-05:00"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0000"' ignoreCase="false" id="secondList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0001-05:00"' ignoreCase="false" id="thirdValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0001-05:00"' ignoreCase="false" id="thirdUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"2004-01-21T15:30:00.0001"' ignoreCase="false" id="thirdList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization06.xml |
|---|
| 0,0 → 1,94 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization06"> |
| <metadata> |
| <title>datatypenormalization06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Normalize document with datatype-normalization set to true. |
| Check if time values were normalized. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"time"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"15:30:00-05:00"' ignoreCase="false" id="firstValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"15:30:00-05:00"' ignoreCase="false" id="firstUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"15:30:00"' ignoreCase="false" id="firstList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"15:30:00.0000-05:00"' ignoreCase="false" id="secondValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"15:30:00.0000-05:00"' ignoreCase="false" id="secondUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"15:30:00.0000"' ignoreCase="false" id="secondList"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <getAttribute var="str" obj="element" name='"value"'/> |
| <assertEquals actual="str" expected='"15:30:00.0001-05:00"' ignoreCase="false" id="thirdValue"/> |
| <getAttribute var="str" obj="element" name='"union"'/> |
| <assertEquals actual="str" expected='"15:30:00.0001-05:00"' ignoreCase="false" id="thirdUnion"/> |
| <textContent var="str" obj="element"/> |
| <assertEquals actual="str" expected='"15:30:00.0001"' ignoreCase="false" id="thirdList"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization07.xml |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization07"> |
| <metadata> |
| <title>datatypenormalization07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The default value for the double element must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"double"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <assertEquals actual="str" expected='"3.1415926E0"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization08.xml |
|---|
| 0,0 → 1,75 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization08"> |
| <metadata> |
| <title>datatypenormalization08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The default value for the decimal element must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <implementationAttribute name="namespaceAware" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"decimal"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <assertEquals actual="str" expected='"3.1415926"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization09.xml |
|---|
| 0,0 → 1,75 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization09"> |
| <metadata> |
| <title>datatypenormalization09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The default value for the boolean element must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"boolean"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <assertEquals actual="str" expected='"true"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization10.xml |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization10"> |
| <metadata> |
| <title>datatypenormalization10</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The default value for the float element must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"float"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <assertEquals actual="str" expected='"3.1415926E0"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization11.xml |
|---|
| 0,0 → 1,75 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization11"> |
| <metadata> |
| <title>datatypenormalization11</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| The default value for the dateTime element must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"dateTime"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <!-- .0 would not be correct, see http://www.w3.org/2001/05/xmlschema-errata#E2-63 --> |
| <assertEquals actual="str" expected='"2004-01-21T20:30:00Z"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization12.xml |
|---|
| 0,0 → 1,75 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization12"> |
| <metadata> |
| <title>datatypenormalization12</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Default values must be provided in canonical lexical form. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"' |
| localName='"time"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <getAttribute var="str" obj="element" name='"default"'/> |
| <!-- .0 would not be correct, see http://www.w3.org/2001/05/xmlschema-errata#E2-63 --> |
| <assertEquals actual="str" expected='"20:30:00Z"' ignoreCase="false" id="firstValue"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization13.xml |
|---|
| 0,0 → 1,80 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization13"> |
| <metadata> |
| <title>datatypenormalization13</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parse document with datatype-normalization set to true. |
| Check if string values were normalized per default whitespace |
| facet of xsd:string. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization2"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization2"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"em"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <assertNotNull actual="childNode" id="childNodeNotNull"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='" EMP 0001 "' ignoreCase="false" id="content"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization14.xml |
|---|
| 0,0 → 1,80 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization14"> |
| <metadata> |
| <title>datatypenormalization14</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parse document with datatype-normalization set to true. |
| Check if string values were normalized per explicit whitespace=preserve. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization2"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization2"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"acronym"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <assertNotNull actual="childNode" id="childNodeNotNull"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='" EMP 0001 "' ignoreCase="false" id="content"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization15.xml |
|---|
| 0,0 → 1,86 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization15"> |
| <metadata> |
| <title>datatypenormalization15</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parse document with datatype-normalization set to true. |
| Check if string values were normalized per an explicit whitespace=collapse. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization2"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization2"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"code"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content1"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content2"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content3"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization16.xml |
|---|
| 0,0 → 1,90 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization16"> |
| <metadata> |
| <title>datatypenormalization16</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parse document with datatype-normalization set to true. |
| Check if string values were normalized per explicit whitespace=replace. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetNormalization" type="boolean"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/><return/></if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetNormalization" obj="domConfig" name='"datatype-normalization2"' value="true"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if> |
| <and> |
| <isTrue value="canSetNormalization"/> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetXMLSchema"/> |
| </and> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="true"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization2"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"sup"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="0"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='" EMP 0001 "' ignoreCase="false" id="content1"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content2"/> |
| <item var="element" obj="elemList" interface="NodeList" index="2"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content3"/> |
| <item var="element" obj="elemList" interface="NodeList" index="3"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content4"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/datatypenormalization17.xml |
|---|
| 0,0 → 1,76 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="datatypenormalization17"> |
| <metadata> |
| <title>datatypenormalization17</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parse document with datatype-normalization set to false. |
| Check if string values were not normalized per an explicit whitespace=collapse. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| </if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <if><isTrue value="canSetValidate"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| </if> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if><isTrue value="canSetXMLSchema"/> |
| <setParameter obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| </if> |
| <setParameter obj="domConfig" name='"datatype-normalization"' value="false"/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization2"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"code"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/disallowdoctype01.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="disallowdoctype01"> |
| <metadata> |
| <title>disallowdoctype01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parsing a document with a doctype should throw a PARSE_ERR if disallow-doctype is true. |
| is false. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-disallow-doctype"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="nullSchemaLanguage" type="DOMString" isNull="true"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="errorCount" type="int" value="0"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaLanguage"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"disallow-doctype"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"disallow-doctype"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"test3"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <if><greater actual="severity" expected="1"/> |
| <assertEquals actual="severity" expected="3" id="isFatalError" ignoreCase="false"/> |
| <assertEquals actual="type" expected='"doctype-not-allowed"' id="isDoctypeNotAllowed" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneError"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/discarddefaultcontent01.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="discarddefaultcontent01"> |
| <metadata> |
| <title>discarddefaultcontent01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Default attributes should be not be serialized if discard-default-content is true. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-discard-default-content"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"discard-default-content"' value="true"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <!-- explicit dir='rtl' should not appear in serialized document --> |
| <assertFalse id="noDirAttr"><contains obj="output" str='"dir="' interface="DOMString"/></assertFalse> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/discarddefaultcontent02.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="discarddefaultcontent02"> |
| <metadata> |
| <title>discarddefaultcontent02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Default attributes should be explicitly serialized if discard-default-content is false. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-discard-default-content"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"discard-default-content"' value="false"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <!-- explicit dir='rtl' should appear in serialized document --> |
| <assertTrue id="hasDirAttr"><contains obj="output" str='"dir="' interface="DOMString"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/dom3tests.ent |
|---|
| 0,0 → 1,78 |
| <!ENTITY level3 "http://www.w3.org/2001/DOM-Test-Suite/Level-3"> |
| <!ENTITY spec "http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save"> |
| <!ENTITY date "<date qualifier='created'>2002-03-23</date>"> |
| <!ENTITY contributor "<contributor>X-Hive Corporation</contributor>"> |
| <!ENTITY creator "<creator>Jeroen van Rotterdam</creator>"> |
| <!ENTITY vars " |
| <var name='implementation' type='DOMImplementation'/> |
| <var name='lsImplementation' type='DOMImplementationLS'/> |
| <var name='inputSource' type='LSInput'/> |
| <var name='document' type='Document'/> |
| <var name='writer' type='LSSerializer'/> |
| <var name='parser' type='LSParser'/> |
| <!-- constants --> |
| <var name='MODE_SYNCHRONOUS' type='short' value='1'/> |
| <var name='MODE_ASYNCHRONOUS' type='short' value='2'/> |
| <var name='DTD_SCHEMATYPE' type='DOMString' value='"http://www.w3.org/TR/REC-xml"'/> |
| <var name='SCHEMA_SCHEMATYPE' type='DOMString' value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name='NULL_SCHEMATYPE' type='DOMString' isNull='true'/> |
| <!-- action types DOMParser.parseWithContext --> |
| <var name='ACTION_REPLACE_CHILDREN' type='short' value='2'/> |
| <var name='ACTION_APPEND_AS_CHILDREN' type='short' value='1'/> |
| <var name='ACTION_INSERT_AFTER' type='short' value='4'/> |
| <var name='ACTION_INSERT_BEFORE' type='short' value='3'/> |
| <var name='ACTION_REPLACE' type='short' value='5'/> |
| <!-- testfiles --> |
| <var name='TEST0' type='DOMString' value='"test0"'/> |
| <var name='TEST1' type='DOMString' value='"test1"'/> |
| <var name='TEST2' type='DOMString' value='"test2"'/> |
| <var name='TEST3' type='DOMString' value='"test3"'/> |
| <var name='TEST4' type='DOMString' value='"test4"'/> |
| <var name='TEST5' type='DOMString' value='"test5"'/> |
| <var name='TEST6' type='DOMString' value='"test6"'/> |
| <var name='TEST7' type='DOMString' value='"test7"'/> |
| <var name='TESTPDF' type='DOMString' value='"testpdf"'/> |
| <implementation var='implementation'/> |
| <assign var='lsImplementation' value='implementation'/> |
| "> |
| <!ENTITY filterVars ""> |
| <!ENTITY errorHandlerVars " |
| <var name='error' type='DOMError'/> |
| <var name='severity' type='short'/> |
| <var name='message' type='DOMString'/> |
| <var name='type' type='DOMString'/> |
| <var name='location' type='DOMLocator'/> |
| "> |
| <!ENTITY assignErrorHandlerVars " |
| <severity var='severity' obj='error' interface='DOMError'/> |
| <message var='message' obj='error' interface='DOMError'/> |
| <type var='type' obj='error' interface='DOMError'/> |
| <location var='location' obj='error' interface='DOMError'/> |
| "> |
| <!ENTITY init "<createLSParser var='parser' obj='lsImplementation' mode='MODE_SYNCHRONOUS' schemaType='NULL_SCHEMATYPE'/> |
| <createLSSerializer var='writer' obj='lsImplementation'/> |
| <createLSInput var='inputSource' obj='lsImplementation'/>"> |
| <!ENTITY parser.setFilter_myfilter "<filter obj='parser' value='myfilter' interface='LSParser'/>"> |
| <!ENTITY SHOW_ELEMENT "1"> |
| <!ENTITY SHOW_TEXT '4'> |
| <!ENTITY SHOW_ALL '65535'> |
| <!ENTITY SHOW_ATTRIBUTE '2'> |
| <!ENTITY SHOW_COMMENT '128'> |
| <!ENTITY FILTER_ACCEPT '1'> |
| <!ENTITY FILTER_REJECT '2'> |
| <!ENTITY FILTER_SKIP '3'> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/elementcontentwhitespace01.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementcontentwhitespace01"> |
| <metadata> |
| <title>elementcontentwhitespace01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with element-content-whitespace = false and validation = true and check that |
| element content whitespace is eliminated. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-element-content-whitespace"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetWhitespace" type="boolean"/> |
| <var name="elemList" type="NodeList"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetWhitespace" obj="domConfig" name='"element-content-whitespace"' value="false"/> |
| <if><and><isTrue value="canSetValidate"/><isTrue value="canSetWhitespace"/></and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"element-content-whitespace"' value="false"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <firstChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="1" ignoreCase="false" id="nodeIsElem"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/elementcontentwhitespace02.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementcontentwhitespace02"> |
| <metadata> |
| <title>elementcontentwhitespace02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with element-content-whitespace and validate = true and check that |
| element content whitespace is not eliminated. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-element-content-whitespace"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="elemList" type="NodeList"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"validate"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| </if> |
| <setParameter obj="domConfig" name='"element-content-whitespace"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <firstChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="nodeIsText"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/elementcontentwhitespace03.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="elementcontentwhitespace03"> |
| <metadata> |
| <title>elementcontentwhitespace03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Serialize a document when element-content-whitespace is false, element content whitespace should be eliminated. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-element-content-whitespace"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="serializerDomConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="output" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetWhitespace" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig var="serializerDomConfig" obj="lsSerializer" interface="LSSerializer"/> |
| <canSetParameter var="canSetWhitespace" obj="serializerDomConfig" name='"element-content-whitespace"' value="false"/> |
| <if><and><isTrue value="canSetValidate"/><isTrue value="canSetWhitespace"/></and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"validate"' value="false"/> |
| <getResourceURI var="resourceURI" href='"test3"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <setParameter obj="serializerDomConfig" name='"element-content-whitespace"' value="false"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertTrue id="noWhitespace"><contains obj="output" str='"<elt0><elt1>"' interface="DOMString"/></assertTrue> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/encoding01.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="encoding01"> |
| <metadata> |
| <title>encoding01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| createLSOutput should create an LSOutput, encoding should be mutable. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSOutput"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSOutput-encoding"/> |
| </metadata> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsOutput" type="LSOutput"/> |
| <var name="encoding" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSOutput var="lsOutput" obj="domImplLS"/> |
| <encoding var="encoding" obj="lsOutput" interface="LSOutput"/> |
| <!-- no definitive statement of expected default value --> |
| <encoding obj="lsOutput" value='"ISO-8859-1"' interface="LSOutput"/> |
| <encoding var="encoding" obj="lsOutput" interface="LSOutput"/> |
| <assertEquals actual="encoding" expected='"ISO-8859-1"' id="isLatin1" ignoreCase="true"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/entities01.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities01"> |
| <metadata> |
| <title>entites01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with entities = false and see that entity references are not present in |
| the element content. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"entities"' value="false"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="1" interface="NodeList"/> |
| <firstChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="acrContentIsText"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/entities02.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities02"> |
| <metadata> |
| <title>entites02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with entities = false and see that entity references are not present in |
| attribute content. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="classAttr" type="Attr"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"entities"' value="false"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <attributes var="attributes" obj="elem"/> |
| <getNamedItem var="classAttr" obj="attributes" name='"class"'/> |
| <lastChild var="node" obj="classAttr" interface="Node"/> |
| <assertNotNull actual="classAttr" id="classAttrChildNotNull"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="classAttrChildIsText"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/entities03.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities03"> |
| <metadata> |
| <title>entites03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with entities = false and see that entity definitions are preserved. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"entities"' value="false"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <doctype var="docType" obj="doc"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities var="entities" obj="docType"/> |
| <getNamedItem var="entity" obj="entities" name='"alpha"'/> |
| <assertNotNull actual="entity" id="entityNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/entities04.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities04"> |
| <metadata> |
| <title>entites04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with entities = true and see that entity references are present in |
| the element content. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"entities"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="1" interface="NodeList"/> |
| <firstChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="5" ignoreCase="false" id="acrContentIsEntRef"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/entities05.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities05"> |
| <metadata> |
| <title>entites05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with entities = true and see that entity references are present in |
| attribute content. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="attributes" type="NamedNodeMap"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <var name="classAttr" type="Attr"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"entities"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="3" interface="NodeList"/> |
| <attributes var="attributes" obj="elem"/> |
| <getNamedItem var="classAttr" obj="attributes" name='"class"'/> |
| <lastChild var="node" obj="classAttr" interface="Node"/> |
| <assertNotNull actual="classAttr" id="classAttrChildNotNull"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="5" ignoreCase="false" id="classAttrChildIsEntRef"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/entities06.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities06"> |
| <metadata> |
| <title>entites06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with entities = true and see that entity definitions are preserved. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="docType" type="DocumentType"/> |
| <var name="entities" type="NamedNodeMap"/> |
| <var name="entity" type="Entity"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"entities"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <doctype var="docType" obj="doc"/> |
| <assertNotNull actual="docType" id="docTypeNotNull"/> |
| <entities var="entities" obj="docType"/> |
| <getNamedItem var="entity" obj="entities" name='"alpha"'/> |
| <assertNotNull actual="entity" id="entityNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/entities07.xml |
|---|
| 0,0 → 1,63 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities07"> |
| <metadata> |
| <title>entities07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| A warning should be dispatched if the base URI of a processing instruction can not be preserved. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="nullSchemaLanguage" type="DOMString" isNull="true"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="warningCount" type="int" value="0"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaLanguage"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"entities"' value="false"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"pibase"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <if><equals actual="type" expected='"pi-base-uri-not-preserved"' ignoreCase="false"/> |
| <assertEquals actual="severity" expected="1" id="isError" ignoreCase="false"/> |
| <increment var="warningCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="warningCount" expected="1" ignoreCase="false" id="hadWarning"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/entities08.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities08"> |
| <metadata> |
| <title>entities08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Entity references should be preserved when entities is true. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="output" type="DOMString"/> |
| <var name="varList" type="NodeList"/> |
| <var name="varNode" type="Node"/> |
| <var name="child" type="Node"/> |
| <var name="childType" type="int"/> |
| <var name="entRef" type="EntityReference"/> |
| <var name="retNode" type="Node"/> |
| <implementation var="domImplLS"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <!-- entity references may be expanded on load |
| if so, create and insert an entity reference into the document --> |
| <getElementsByTagName var="varList" obj="doc" |
| tagname='"var"' interface="Document"/> |
| <item var="varNode" obj="varList" index="2" interface="NodeList"/> |
| <firstChild var="child" obj="varNode" interface="Node"/> |
| <nodeType var="childType" obj="child"/> |
| <if><equals actual="childType" expected="1" ignoreCase="false"/> |
| <createEntityReference var="entRef" obj="doc" |
| name='"ent4"'/> |
| <appendChild var="retNode" obj="varNode" newChild="entRef"/> |
| </if> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"entities"' value="true"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertTrue id="hasEntRef"><contains obj="output" str='"ent4;"' interface="DOMString"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/entities09.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="entities09"> |
| <metadata> |
| <title>entities09</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Entity references should be expanded when entities is false. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-entities"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="output" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <load var="doc" href="hc_staff" willBeModified="true"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"entities"' value="false"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertFalse id="noEntRef"><contains obj="output" str='"ent4;"' interface="DOMString"/></assertFalse> |
| <assertTrue id="entDef"><contains obj="output" str='"!ENTITY"' interface="DOMString"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/CVS/Entries |
|---|
| 0,0 → 1,37 |
| D/subdir//// |
| /canonicalform01.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /canonicalform02.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /canonicalform03.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /characternormalization1.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /datatype_normalization.svg.xsd/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /datatype_normalization.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /datatype_normalization.xsd/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /datatype_normalization2.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /datatype_normalization2.xsd/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /hc_staff.svg/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /hc_staff.svg.xsd/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /hc_staff.xhtml/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /hc_staff.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /hc_staff.xsd/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /namespaces1.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /pibase.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /schematype1.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /svgtest.js/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /svgunit.js/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /test0.svg/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /test0.xml/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /test1.xml/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /test2.xml/1.3/Fri Apr 3 02:47:57 2009/-kb/ |
| /test3.xml/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /test4.xml/1.3/Fri Apr 3 02:47:57 2009/-kb/ |
| /test5.xml/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /test7.xml/1.3/Fri Apr 3 02:47:57 2009/-kb/ |
| /testpdf.pdf/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /testsvg.dtd/1.2/Fri Apr 3 02:47:57 2009/-kb/ |
| /unsupportedencoding1.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /validate1.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /validateschema1.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /wellformed1.xml/1.2/Fri Apr 3 02:47:57 2009// |
| /wellformed2.xml/1.2/Fri Apr 3 02:47:57 2009// |
| /wellformed3.xml/1.1/Fri Apr 3 02:47:57 2009// |
| /xhtml1-strict.dtd/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/ls/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/CVS/Template |
|---|
| --- test/testcases/tests/level3/ls/files/canonicalform01.xml (nonexistent) |
| +++ test/testcases/tests/level3/ls/files/canonicalform01.xml (revision 4364) |
| @@ -0,0 +1,14 @@ |
| +<?xml version="1.0"?> |
| + |
| +<?xml-stylesheet href="doc.xsl" |
| + type="text/xsl" ?> |
| + |
| +<!DOCTYPE html SYSTEM "xhtml1-strict.dtd"> |
| +<html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform01</title></head><body onload="parent.loadComplete()"> |
| +<p>Hello, world!<!-- Comment 1 --></p></body></html> |
| + |
| +<?pi-without-data ?> |
| + |
| +<!-- Comment 2 --> |
| + |
| +<!-- Comment 3 --> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/canonicalform02.xml |
|---|
| 0,0 → 1,11 |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform02</title></head><body onload="parent.loadComplete()"> |
| <acronym> </acronym> |
| <em> A B </em> |
| <p> |
| A |
| <acronym> </acronym> |
| B |
| <em> A B </em> |
| C |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/canonicalform03.xml |
|---|
| 0,0 → 1,18 |
| <!DOCTYPE html [<!ATTLIST acronym title CDATA "default">]> |
| <html xmlns="http://www.w3.org/1999/xhtml"><head><title>canonicalform03</title></head><body onload="parent.loadComplete()"> |
| <br /> |
| <br ></br> |
| <div name = "elem3" id="elem3" /> |
| <div name="elem4" id="elem4" ></div> |
| <div a:attr="out" b:attr="sorted" name="all" class="I'm" |
| xmlns:b="http://www.ietf.org" |
| xmlns:a="http://www.w3.org" |
| xmlns="http://example.org"/> |
| <div xmlns="" xmlns:a="http://www.w3.org"> |
| <div xmlns="http://www.ietf.org"> |
| <div xmlns="" xmlns:a="http://www.w3.org"> |
| <acronym xmlns="" xmlns:a="http://www.ietf.org"/> |
| </div> |
| </div> |
| </div> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/characternormalization1.xml |
|---|
| 0,0 → 1,4 |
| <!DOCTYPE suçon [ |
| <!ELEMENT suçon EMPTY> |
| ]> |
| <suçon/> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/datatype_normalization.svg.xsd |
|---|
| 0,0 → 1,60 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema is attempts to use every construct that could |
| be interrogated by DOM Level 3 and is no way intended to |
| be a general purpose schema for SVG |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/2000/svg" |
| xmlns="http://www.w3.org/2000/svg" |
| xmlns:data="http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"> |
| <xsd:import namespace="http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization" schemaLocation="datatype_normalization.xsd"/> |
| <xsd:element name="svg"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="rect"/> |
| <xsd:element ref="script"/> |
| <xsd:element ref="data:data"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="rect"> |
| <xsd:complexType> |
| <xsd:attribute name="x" type="xsd:double" use="required"/> |
| <xsd:attribute name="y" type="xsd:double" use="required"/> |
| <xsd:attribute name="height" type="xsd:double" use="required"/> |
| <xsd:attribute name="width" type="xsd:double" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="script"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="xsd:string"> |
| <xsd:attribute name="type" type="xsd:string" use="required"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/datatype_normalization.xml |
|---|
| 0,0 → 1,90 |
| <!DOCTYPE svg [ |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| <!ELEMENT svg (rect, script, data)> |
| <!ATTLIST svg |
| xmlns CDATA #IMPLIED |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ELEMENT data (double*, boolean*, decimal*, float*, dateTime*, time*)> |
| <!ATTLIST data xmlns CDATA #IMPLIED> |
| <!ELEMENT double (#PCDATA)> |
| <!ATTLIST double |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT boolean (#PCDATA)> |
| <!ATTLIST boolean |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT decimal (#PCDATA)> |
| <!ATTLIST decimal |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT float (#PCDATA)> |
| <!ATTLIST float |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT dateTime (#PCDATA)> |
| <!ATTLIST dateTime |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| <!ELEMENT time (#PCDATA)> |
| <!ATTLIST time |
| value CDATA #IMPLIED |
| union CDATA #IMPLIED> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg" |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/2000/svg datatype_normalization.svg.xsd"> |
| <rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <data xmlns='http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization'> |
| <double value=" |
| +0003.141592600E+0000 " union=" +0003.141592600E+0000 |
| "> -31415926.00E-7 |
| 2.718</double> |
| <double value=" NaN" union="NaN "> INF -INF </double> |
| <double value=" |
| 1 " union="1 |
| "> -0</double> |
| <boolean value=" |
| true" union="false |
| "> false true false </boolean> |
| <boolean value=" |
| 1" union=" 0 |
| ">0 1 0 </boolean> |
| <decimal value=" +0003.141592600 " union=" +0003.141592600 "> +10 .1 </decimal> |
| <decimal value=" 01 " union=" 01 "> -.001 </decimal> |
| <float value=" +0003.141592600E+0000 " union=" +0003.141592600E+0000 "> -31415926.00E-7 |
| 2.718</float> |
| <float value=" NaN " union=" NaN "> INF -INF </float> |
| <float value=" |
| 1 " union="1 |
| ">-0</float> |
| <dateTime value=" |
| 2004-01-21T15:30:00-05:00" union="2004-01-21T20:30:00-05:00 |
| ">2004-01-21T15:30:00 |
| 2004-01-21T15:30:00Z</dateTime> |
| <dateTime value=" |
| 2004-01-21T15:30:00.0000-05:00" union="2004-01-21T15:30:00.0000-05:00 |
| "> 2004-01-21T15:30:00.0000 </dateTime> |
| <dateTime value="2004-01-21T15:30:00.0001-05:00" union="2004-01-21T15:30:00.0001-05:00">2004-01-21T15:30:00.0001</dateTime> |
| <time value=" |
| 15:30:00-05:00" union="15:30:00-05:00 |
| "> 15:30:00 </time> |
| <time value=" |
| 15:30:00.0000-05:00" union=" 15:30:00.0000-05:00 |
| ">15:30:00.0000</time> |
| <time value=" |
| 15:30:00.0001-05:00" union="15:30:00.0001-05:00 |
| ">15:30:00.0001</time> |
| </data> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/datatype_normalization.xsd |
|---|
| 0,0 → 1,212 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization" |
| xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3/datatype_normalization"> |
| <xsd:element name="data"> |
| <xsd:complexType> |
| <xsd:choice minOccurs="0" maxOccurs="unbounded"> |
| <xsd:element ref="double"/> |
| <xsd:element ref="boolean"/> |
| <xsd:element ref="decimal"/> |
| <xsd:element ref="float"/> |
| <xsd:element ref="dateTime"/> |
| <xsd:element ref="time"/> |
| </xsd:choice> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myDouble"> |
| <xsd:restriction base="xsd:double"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDoubleList"> |
| <xsd:list itemType="myDouble"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDoubleUnion"> |
| <xsd:union memberTypes="myDouble xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="double"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myDoubleList"> |
| <xsd:attribute name="value" type="myDouble" use="required"/> |
| <xsd:attribute name="union" type="myDoubleUnion" use="required"/> |
| <xsd:attribute name="default" type="myDouble" |
| default="+0003.141592600E+0000" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myBoolean"> |
| <xsd:restriction base="xsd:boolean"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myBooleanList"> |
| <xsd:list itemType="myBoolean"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myBooleanUnion"> |
| <xsd:union memberTypes="myBoolean xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="boolean"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myBooleanList"> |
| <xsd:attribute name="value" type="myBoolean" use="required"/> |
| <xsd:attribute name="union" type="myDoubleUnion" use="required"/> |
| <xsd:attribute name="default" type="myBoolean" |
| default="1" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myDecimal"> |
| <xsd:restriction base="xsd:decimal"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDecimalList"> |
| <xsd:list itemType="myDecimal"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDecimalUnion"> |
| <xsd:union memberTypes="myDecimal xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="decimal"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myDecimalList"> |
| <xsd:attribute name="value" type="myDecimal" use="required"/> |
| <xsd:attribute name="union" type="myDecimalUnion" use="required"/> |
| <xsd:attribute name="default" type="myDecimal" |
| default="+0003.141592600" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myFloat"> |
| <xsd:restriction base="xsd:float"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myFloatList"> |
| <xsd:list itemType="myFloat"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myFloatUnion"> |
| <xsd:union memberTypes="myFloat xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="float"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myFloatList"> |
| <xsd:attribute name="value" type="myFloat" use="required"/> |
| <xsd:attribute name="union" type="myFloatUnion" use="required"/> |
| <xsd:attribute name="default" type="myDouble" |
| default="+0003.141592600E+0000" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myDateTime"> |
| <xsd:restriction base="xsd:dateTime"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDateTimeList"> |
| <xsd:list itemType="myDateTime"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myDateTimeUnion"> |
| <xsd:union memberTypes="myDateTime xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="dateTime"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myDateTimeList"> |
| <xsd:attribute name="value" type="myDateTime" use="required"/> |
| <xsd:attribute name="union" type="myDateTimeUnion" use="required"/> |
| <xsd:attribute name="default" type="myDateTime" |
| default="2004-01-21T15:30:00-05:00" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myTime"> |
| <xsd:restriction base="xsd:time"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myTimeList"> |
| <xsd:list itemType="myTime"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myTimeUnion"> |
| <xsd:union memberTypes="myTime xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="time"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myTimeList"> |
| <xsd:attribute name="value" type="myTime" use="required"/> |
| <xsd:attribute name="union" type="myTimeUnion" use="required"/> |
| <xsd:attribute name="default" type="myTime" |
| default="15:30:00-05:00" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="myUnion"> |
| <xsd:union memberTypes="xsd:integer xsd:string"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myUnionList"> |
| <xsd:list itemType="myUnion"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="myUnionUnion"> |
| <xsd:union memberTypes="myUnion xsd:anyURI"/> |
| </xsd:simpleType> |
| <xsd:element name="union"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="myUnionList"> |
| <xsd:attribute name="value" type="myUnion" use="required"/> |
| <xsd:attribute name="union" type="myUnionUnion" use="required"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/datatype_normalization2.xml |
|---|
| 0,0 → 1,33 |
| <?xml version="1.0"?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| ]> |
| <html xmlns='http://www.w3.org/1999/xhtml' |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/1999/xhtml datatype_normalization2.xsd"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>datatype_normalization2</title></head><body onload="parent.loadComplete()"> |
| <p> |
| <!-- preserve, string default --> |
| <em> EMP 0001 </em> |
| <!-- explicit preserve --> |
| <acronym> EMP 0001 </acronym> |
| <!-- explicit collapse --> |
| <code> |
| EMP 0001 |
| </code> |
| <code>EMP 0001</code> |
| <code>EMP 0001</code> |
| <!-- explicit replace --> |
| <sup> |
| EMP 0001 |
| </sup> |
| <sup>EMP 0001</sup> |
| <sup>EMP 0001</sup> |
| <sup>EMP |
| 0001</sup> |
| </p> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/datatype_normalization2.xsd |
|---|
| 0,0 → 1,99 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema is intended to support specific DOM L3 tests is no way intended to |
| be a general purpose schema for XHTML |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/1999/xhtml" |
| xmlns="http://www.w3.org/1999/xhtml"> |
| <xsd:element name="html"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="head"/> |
| <xsd:element ref="body"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="head"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="meta"/> |
| <xsd:element ref="title"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="title" type="xsd:string"/> |
| <xsd:element name="meta"> |
| <xsd:complexType> |
| <xsd:attribute name="http-equiv" type="xsd:string" use="required"/> |
| <xsd:attribute name="content" type="xsd:string" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="body"> |
| <xsd:complexType> |
| <xsd:sequence minOccurs="0" maxOccurs="unbounded"> |
| <xsd:element ref="p"/> |
| </xsd:sequence> |
| <xsd:attribute name="onload" type="xsd:string" use="optional"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="p"> |
| <xsd:complexType> |
| <xsd:choice minOccurs="0" maxOccurs="unbounded"> |
| <xsd:element ref="em"/> |
| <xsd:element ref="code"/> |
| <xsd:element ref="sup"/> |
| <xsd:element ref="acronym"/> |
| </xsd:choice> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="em" type="xsd:string"/> |
| <xsd:simpleType name="acronym"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:whiteSpace value="preserve"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="acronym" type="acronym"/> |
| <xsd:simpleType name="code"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:whiteSpace value="collapse"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="code" type="code"/> |
| <xsd:simpleType name="sup"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:whiteSpace value="replace"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="sup" type="sup"/> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/hc_staff.svg |
|---|
| 0,0 → 1,87 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST p |
| dir CDATA 'rtl' |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED> |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ATTLIST acronym xsi:noNamespaceSchemaLocation CDATA #IMPLIED> |
| <!ENTITY ent4 "<span xmlns='http://www.w3.org/1999/xhtml'>Element data</span><?PItarget PIdata?>"> |
| <!ATTLIST span xmlns CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| <!ELEMENT svg (rect, script, body)> |
| <!ATTLIST svg |
| xmlns CDATA #IMPLIED |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ATTLIST body xmlns CDATA #IMPLIED> |
| ]> |
| <svg xmlns="http://www.w3.org/2000/svg" |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/2000/svg hc_staff.svg.xsd"> |
| <rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script><body xmlns="http://www.w3.org/1999/xhtml"> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" xsi:noNamespaceSchemaLocation="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0002</em> |
| <strong>Martha Raynolds |
| <![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.netzero.com"> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>&ent4;</var> |
| <acronym title="Yes" class="No" id="_98553" xsi:noNamespaceSchemaLocation="Yes">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p xmlns:nm="http://www.altavista.com"> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα" id="_98556" xsi:noNamespaceSchemaLocation="Yes">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p xmlns:emp2="http://www.nist.gov"> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/hc_staff.svg.xsd |
|---|
| 0,0 → 1,60 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema is attempts to use every construct that could |
| be interrogated by DOM Level 3 and is no way intended to |
| be a general purpose schema for SVG |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/2000/svg" |
| xmlns="http://www.w3.org/2000/svg" |
| xmlns:xhtml="http://www.w3.org/1999/xhtml"> |
| <xsd:import namespace="http://www.w3.org/1999/xhtml" schemaLocation="hc_staff.xsd"/> |
| <xsd:element name="svg"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="rect"/> |
| <xsd:element ref="script"/> |
| <xsd:element ref="xhtml:body"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="rect"> |
| <xsd:complexType> |
| <xsd:attribute name="x" type="xsd:double" use="required"/> |
| <xsd:attribute name="y" type="xsd:double" use="required"/> |
| <xsd:attribute name="height" type="xsd:double" use="required"/> |
| <xsd:attribute name="width" type="xsd:double" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="script"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="xsd:string"> |
| <xsd:attribute name="type" type="xsd:string" use="required"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/hc_staff.xhtml |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST p |
| dir CDATA 'rtl' |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED> |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ATTLIST acronym xsi:noNamespaceSchemaLocation CDATA #IMPLIED> |
| <!ENTITY ent4 "<span xmlns='http://www.w3.org/1999/xhtml'>Element data</span><?PItarget PIdata?>"> |
| <!ATTLIST span xmlns CDATA #IMPLIED> |
| ]> |
| <!-- This is comment number 1.--> |
| <html xmlns='http://www.w3.org/1999/xhtml' |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/1999/xhtml hc_staff.xsd"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title><script type="text/javascript" src="svgunit.js"/><script charset="UTF-8" type="text/javascript" src="svgtest.js"/><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" xsi:noNamespaceSchemaLocation="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0002</em> |
| <strong>Martha Raynolds |
| <![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.netzero.com"> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>&ent4;</var> |
| <acronym title="Yes" class="No" id="_98553" xsi:noNamespaceSchemaLocation="Yes">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p xmlns:nm="http://www.altavista.com"> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα" id="_98556" xsi:noNamespaceSchemaLocation="Yes">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p xmlns:emp2="http://www.nist.gov"> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/hc_staff.xml |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE html |
| PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" |
| "xhtml1-strict.dtd" [ |
| <!ENTITY alpha "α"> |
| <!ENTITY beta "β"> |
| <!ENTITY gamma "γ"> |
| <!ENTITY delta "δ"> |
| <!ENTITY epsilon "ε"> |
| <!ENTITY alpha "ζ"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST p |
| dir CDATA 'rtl' |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED> |
| <!ATTLIST html |
| xmlns:xsi CDATA #IMPLIED |
| xsi:schemaLocation CDATA #IMPLIED> |
| <!ATTLIST acronym xsi:noNamespaceSchemaLocation CDATA #IMPLIED> |
| <!ENTITY ent4 "<span xmlns='http://www.w3.org/1999/xhtml'>Element data</span><?PItarget PIdata?>"> |
| <!ATTLIST span xmlns CDATA #IMPLIED> |
| ]> |
| <!-- This is comment number 1.--> |
| <html xmlns='http://www.w3.org/1999/xhtml' |
| xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:schemaLocation="http://www.w3.org/1999/xhtml hc_staff.xsd"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>hc_staff</title><script type="text/javascript" src="svgunit.js"/><script charset="UTF-8" type="text/javascript" src="svgtest.js"/><script type='text/javascript'>function loadComplete() { startTest(); }</script></head><body onload="parent.loadComplete()"> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0001</em> |
| <strong>Margaret Martin</strong> |
| <code>Accountant</code> |
| <sup>56,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" xsi:noNamespaceSchemaLocation="Yes">1230 North Ave. Dallas, Texas 98551</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.usa.com"> |
| <em>EMP0002</em> |
| <strong>Martha Raynolds |
| <![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></strong> |
| <code>Secretary</code> |
| <sup>35,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">β Dallas, γ |
| 98554</acronym> |
| </p> |
| <p xmlns:dmstc="http://www.netzero.com"> |
| <em>EMP0003</em> |
| <strong>Roger |
| Jones</strong> |
| <code>Department Manager</code> |
| <sup>100,000</sup> |
| <var>&ent4;</var> |
| <acronym title="Yes" class="No" id="_98553" xsi:noNamespaceSchemaLocation="Yes">PO Box 27 Irving, texas 98553</acronym> |
| </p> |
| <p xmlns:nm="http://www.altavista.com"> |
| <em>EMP0004</em> |
| <strong>Jeny Oconnor</strong> |
| <code>Personnel Director</code> |
| <sup>95,000</sup> |
| <var>Female</var> |
| <acronym title="Yes" class="Yα" id="_98556" xsi:noNamespaceSchemaLocation="Yes">27 South Road. Dallas, Texas 98556</acronym> |
| </p> |
| <p xmlns:emp2="http://www.nist.gov"> |
| <em>EMP0005</em> |
| <strong>Robert Myers</strong> |
| <code>Computer Specialist</code> |
| <sup>90,000</sup> |
| <var>male</var> |
| <acronym title="Yes" class="Yes" xsi:noNamespaceSchemaLocation="Yes">1821 Nordic. Road, Irving Texas 98558</acronym> |
| </p> |
| </body></html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/hc_staff.xsd |
|---|
| 0,0 → 1,250 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This schema is attempts to use every construct that could |
| be interrogated by DOM Level 3 and is no way intended to |
| be a general purpose schema for XHTML |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" |
| targetNamespace="http://www.w3.org/1999/xhtml" |
| xmlns="http://www.w3.org/1999/xhtml"> |
| <xsd:element name="html"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="head"/> |
| <xsd:element ref="body"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="head"> |
| <xsd:complexType> |
| <xsd:sequence> |
| <xsd:element ref="meta"/> |
| <xsd:element ref="title"/> |
| <xsd:element ref="script" minOccurs="0" maxOccurs="unbounded"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="meta"> |
| <xsd:complexType> |
| <xsd:attribute name="http-equiv" type="xsd:string" use="required"/> |
| <xsd:attribute name="content" type="xsd:string" use="required"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="script"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="xsd:string"> |
| <xsd:attribute name="src" type="xsd:string" use="optional"/> |
| <xsd:attribute name="charset" type="xsd:string" use="optional"/> |
| <xsd:attribute name="type" type="xsd:string" use="required"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:element name="title" type="xsd:string"/> |
| <xsd:element name="body"> |
| <xsd:complexType> |
| <xsd:sequence minOccurs="0" maxOccurs="unbounded"> |
| <xsd:element ref="p"/> |
| </xsd:sequence> |
| <xsd:attribute name="onload" type="xsd:string" use="optional"/> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="classType"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="Yes"/> |
| <xsd:enumeration value="No"/> |
| <xsd:enumeration value="Yα"/> |
| <xsd:enumeration value="Y"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:complexType name="part1"> |
| <xsd:sequence> |
| <xsd:element ref="em"/> |
| <xsd:element ref="strong"/> |
| <xsd:element ref="code"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| <xsd:complexType name="pType"> |
| <xsd:complexContent> |
| <xsd:extension base="part1"> |
| <xsd:sequence> |
| <xsd:element ref="sup"/> |
| <xsd:element ref="var"/> |
| <xsd:element ref="acronym"/> |
| </xsd:sequence> |
| <xsd:attribute name="title" type="xsd:string" use="optional"/> |
| <xsd:attribute name="class" type="classType" use="optional"/> |
| <xsd:attribute name="dir" type="dirType" use="optional" default="rtl"/> |
| <xsd:attribute name="foo" type="xsd:string" use="optional"/> |
| </xsd:extension> |
| </xsd:complexContent> |
| </xsd:complexType> |
| <xsd:element name="p"> |
| <xsd:complexType> |
| <xsd:complexContent> |
| <xsd:restriction base="pType"> |
| <xsd:sequence> |
| <xsd:element ref="em"/> |
| <xsd:element ref="strong"/> |
| <xsd:element ref="code"/> |
| <xsd:element ref="sup"/> |
| <xsd:element ref="var"/> |
| <xsd:element ref="acronym"/> |
| </xsd:sequence> |
| <xsd:attribute name="title" type="xsd:string" use="optional"/> |
| <xsd:attribute name="class" type="classType" use="optional"/> |
| <xsd:attribute name="dir" type="dirType" use="optional" default="rtl"/> |
| <xsd:attribute name="foo" type="xsd:string" use="prohibited"/> |
| </xsd:restriction> |
| </xsd:complexContent> |
| </xsd:complexType> |
| </xsd:element> |
| <xsd:simpleType name="emp0001_3Type"> |
| <xsd:restriction base="xsd:ID"> |
| <xsd:enumeration value="EMP0001"/> |
| <xsd:enumeration value="EMP0002"/> |
| <xsd:enumeration value="EMP0003"/> |
| <xsd:enumeration value="EMP0004"/> |
| <xsd:enumeration value="EMP0005"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="emp0004_5Type"> |
| <xsd:restriction base="xsd:ID"> |
| <xsd:enumeration value="EMP0006"/> |
| <xsd:enumeration value="EMP0007"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="unboundedEmType"> |
| <xsd:union memberTypes="emp0001_3Type emp0004_5Type"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="emType"> |
| <xsd:restriction base="unboundedEmType"> |
| <xsd:pattern value="EMP[0-9]*"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="em" type="emType"/> |
| <xsd:simpleType name="unboundedStrongType"> |
| <xsd:list itemType="xsd:string"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="strongType"> |
| <xsd:restriction base="unboundedStrongType"> |
| <xsd:maxLength value="100"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="strong" type="strongType"/> |
| <!-- union of union and union of list --> |
| <xsd:simpleType name="integers"> |
| <xsd:list itemType="xsd:integer"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="sup"> |
| <xsd:union memberTypes="emType integers xsd:string"/> |
| </xsd:simpleType> |
| <xsd:element name="sup" type="sup"/> |
| <!-- list of union of union --> |
| <xsd:simpleType name="supervisoryTitle"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="Specialist"/> |
| <xsd:enumeration value="Director"/> |
| <xsd:enumeration value="Manager"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="nonSupervisoryTitle"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="Accountant"/> |
| <xsd:enumeration value="Secretary"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="title"> |
| <xsd:union memberTypes="supervisoryTitle nonSupervisoryTitle"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="field"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="Department"/> |
| <xsd:enumeration value="Personnel"/> |
| <xsd:enumeration value="Computer"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:simpleType name="codeItem"> |
| <xsd:union memberTypes="field title"/> |
| </xsd:simpleType> |
| <xsd:simpleType name="code"> |
| <xsd:list itemType="codeItem"/> |
| </xsd:simpleType> |
| <xsd:element name="code" type="code"/> |
| <xsd:element name="span" type="xsd:string"/> |
| <xsd:complexType name="var" mixed="true"> |
| <xsd:sequence> |
| <xsd:element ref="span" minOccurs="0"/> |
| </xsd:sequence> |
| </xsd:complexType> |
| <xsd:element name="var" type="var"/> |
| <xsd:simpleType name="dirType"> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="ltr"/> |
| <xsd:enumeration value="rtl"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| <xsd:element name="acronym"> |
| <xsd:complexType> |
| <xsd:simpleContent> |
| <xsd:extension base="xsd:string"> |
| <xsd:attribute name="class" type="classType" use="optional"/> |
| <xsd:attribute name="title" type="xsd:string" use="optional"/> |
| <xsd:attribute name="id" type="xsd:ID" use="optional"/> |
| </xsd:extension> |
| </xsd:simpleContent> |
| </xsd:complexType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/namespaces1.xml |
|---|
| 0,0 → 1,0 |
| <bad:ns:tag/> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/pibase.xml |
|---|
| 0,0 → 1,10 |
| <!DOCTYPE root [ |
| <!ELEMENT root (one, more)> |
| <!ELEMENT one (two)> |
| <!ELEMENT two EMPTY> |
| <!ELEMENT more EMPTY> |
| <!ENTITY e SYSTEM 'subdir/myentity.ent'> |
| ]> |
| <root> |
| &e; |
| </root> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/schematype1.xml |
|---|
| 0,0 → 1,2 |
| <elt0 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| xsi:noNamespaceSchemaLocation="validateschema1.xml"/> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/subdir/CVS/Entries |
|---|
| 0,0 → 1,2 |
| /myentity.ent/1.1/Fri Apr 3 02:47:57 2009/-kb/ |
| D |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/subdir/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/ls/files/subdir |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/subdir/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/subdir/CVS/Template |
|---|
| --- test/testcases/tests/level3/ls/files/subdir/myentity.ent (nonexistent) |
| +++ test/testcases/tests/level3/ls/files/subdir/myentity.ent (revision 4364) |
| @@ -0,0 +1,5 @@ |
| +<one> |
| + <two/> |
| +</one> |
| +<?pi 3.14159?> |
| +<more/> |
| \ No newline at end of file |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/test0.svg |
|---|
| 0,0 → 1,11 |
| <?xml version="1.0"?> |
| <!DOCTYPE svg [ |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <svg xmlns='http://www.w3.org/2000/svg'><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <elt0 xmlns="http://www.example.com"> |
| <elt1>the first element elt1</elt1><elt1>the second element elt1</elt1> |
| <elt2/> |
| </elt0> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/test0.xml |
|---|
| 0,0 → 1,5 |
| <?xml version="1.0"?> |
| <elt0> |
| <elt1>the first element elt1</elt1><elt1>the second element elt1</elt1> |
| <elt2/> |
| </elt0> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/test1.xml |
|---|
| 0,0 → 1,0 |
| <?xml version="1.0"?><elt0><elt1>remove me</elt1></elt0> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/test2.xml |
|---|
| 0,0 → 1,0 |
| <elt2><elt3>an element</elt3></elt2> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/test3.xml |
|---|
| 0,0 → 1,12 |
| <?xml version="1.0"?> |
| <!DOCTYPE elt0 [ |
| <!ELEMENT elt0 (elt1+)> |
| <!ELEMENT elt1 (#PCDATA)> |
| <!ATTLIST elt1 attr1 CDATA #FIXED "attr1"> |
| ]> |
| <elt0> |
| <elt1>an element</elt1> |
| </elt0> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/test4.xml |
|---|
| 0,0 → 1,13 |
| <?xml version="1.0"?> |
| <!DOCTYPE elt0 [ |
| <!ELEMENT elt0 (elt1+,elt2?)> |
| <!ELEMENT elt1 (#PCDATA)> |
| <!ELEMENT elt2 EMPTY> |
| <!ENTITY ref SYSTEM "test5.xml"> |
| ]> |
| <elt0> |
| <elt1>first elt1</elt1> |
| &ref; |
| </elt0> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/test5.xml |
|---|
| 0,0 → 1,0 |
| <elt1>second elt1</elt1> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/test7.xml |
|---|
| 0,0 → 1,18 |
| <?xml version="1.0"?> |
| <!DOCTYPE elt0 [ |
| <!ELEMENT elt0 (elt1+)> |
| <!ATTLIST elt0 base CDATA #IMPLIED> |
| <!ENTITY logo SYSTEM "logo.png" NDATA PNG> |
| <!NOTATION PNG SYSTEM "image/png"> |
| <!ELEMENT elt1 (#PCDATA)> |
| <!ATTLIST elt1 source ENTITY #REQUIRED> |
| <!ENTITY ref PUBLIC "-//X-Hive//native xml storage//EN" "test5.xml"> |
| ]> |
| <elt0 base="base"> |
| <elt1 source="logo">first elt1</elt1> |
| &ref; |
| </elt0> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/testpdf.pdf |
|---|
| 0,0 → 1,5 |
| <?xml version="1.0"?> |
| <elt0> |
| <elt1>the first element elt1</elt1><elt1>the second element elt1</elt1> |
| <elt2/> |
| </elt0> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/testsvg.dtd |
|---|
| 0,0 → 1,13 |
| <!ELEMENT svg (rect, script, (elt0|elt1)*)> |
| <!ATTLIST svg |
| xmlns CDATA #FIXED "http://www.w3.org/2000/svg" |
| name CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/unsupportedencoding1.xml |
|---|
| 0,0 → 1,2 |
| <?xml version="1.0" encoding="UTF-90210"?> |
| <html/> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/validate1.xml |
|---|
| 0,0 → 1,4 |
| <!DOCTYPE elt0 [ |
| <!ELEMENT elt0 (elt0)> |
| ]> |
| <elt0/> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/validateschema1.xml |
|---|
| 0,0 → 1,23 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" > |
| <xsd:element name="elt0"> |
| <xsd:complexType/> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/wellformed1.xml |
|---|
| 0,0 → 1,8 |
| <?xml version="1.0"?> |
| <!DOCTYPE html SYSTEM 'xhtml1-strict.dtd'> |
| <html> |
| <head><title>wellformed1</title></head> |
| <body> |
| <h×2/> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/wellformed2.xml |
|---|
| 0,0 → 1,8 |
| <?xml version="1.0"?> |
| <!DOCTYPE html SYSTEM 'xhtml1-strict.dtd'> |
| <html> |
| <head><title>Not well-formed</title></head> |
| <body> |
| <p wor×ld='bad name'/> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/wellformed3.xml |
|---|
| 0,0 → 1,7 |
| <?xml version="1.0"?> |
| <!DOCTYPE html SYSTEM 'xhtml1-strict.dtd'> |
| <html> |
| <head><title>wellformed1</title></head> |
| <body title="<"> |
| </body> |
| </html> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/files/xhtml1-strict.dtd |
|---|
| 0,0 → 1,65 |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!-- |
| This is a radically simplified DTD for use in the DOM Test Suites |
| due to a XML non-conformance of one implementation in processing |
| parameter entities. When that non-conformance is resolved, |
| this DTD can be replaced by the normal DTD for XHTML. |
| --> |
| <!ELEMENT html (head, body)> |
| <!ATTLIST html xmlns CDATA #IMPLIED> |
| <!ELEMENT head (meta?,title,script*)> |
| <!ELEMENT meta EMPTY> |
| <!ATTLIST meta |
| http-equiv CDATA #IMPLIED |
| content CDATA #IMPLIED> |
| <!ELEMENT title (#PCDATA)> |
| <!ELEMENT body (p*)> |
| <!ATTLIST body onload CDATA #IMPLIED> |
| <!ELEMENT p (#PCDATA|em|strong|code|sup|var|acronym|abbr)*> |
| <!ATTLIST p |
| xmlns:dmstc CDATA #IMPLIED |
| xmlns:nm CDATA #IMPLIED |
| xmlns:emp2 CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT em (#PCDATA)> |
| <!ELEMENT span (#PCDATA)> |
| <!ELEMENT strong (#PCDATA)> |
| <!ELEMENT code (#PCDATA)> |
| <!ELEMENT sup (#PCDATA)> |
| <!ELEMENT var (#PCDATA|span)*> |
| <!ELEMENT acronym (#PCDATA)> |
| <!ATTLIST acronym |
| title CDATA #IMPLIED |
| class CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT abbr (#PCDATA)> |
| <!ATTLIST abbr |
| title CDATA #IMPLIED |
| class CDATA #IMPLIED |
| id ID #IMPLIED |
| > |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script |
| type CDATA #IMPLIED |
| src CDATA #IMPLIED |
| charset CDATA #IMPLIED> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/infoset01.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset01"> |
| <metadata> |
| <title>infoset01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with a DTD that doesn't match content with infoset=true, should load without complaint. |
| </description> |
| <date qualifier="created">2004-03-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-infoset"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <getResourceURI var="resourceURI" href='"validate1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="elem" obj="doc"/> |
| <assertNotNull actual="elem" id="docElemNotNull"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"elt0"' ignoreCase="false" id="docElemName"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/infoset02.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset02"> |
| <metadata> |
| <title>infoset02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with entities = false and see that entity references are not present in |
| the element content. |
| </description> |
| <date qualifier="created">2004-03-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-infoset"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"acronym"' interface="Document"/> |
| <item var="elem" obj="elemList" index="1" interface="NodeList"/> |
| <firstChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="acrContentIsText"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/infoset03.xml |
|---|
| 0,0 → 1,76 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset03"> |
| <metadata> |
| <title>infoset03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parse document with infoset set to true. |
| Check if string values were not normalized per an explicit whitespace=collapse. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-datatype-normalization"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="element" type="Element"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="str" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetXMLSchema" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="childNode" type="Node"/> |
| <var name="childValue" type="DOMString"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="xsdNS"/> |
| <if><isNull obj="lsParser"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| </if> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <if><isTrue value="canSetValidate"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| </if> |
| <canSetParameter var="canSetXMLSchema" obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| <if><isTrue value="canSetXMLSchema"/> |
| <setParameter obj="domConfig" name='"schema-type"' value="xsdNS"/> |
| </if> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <getResourceURI var="resourceURI" href='"datatype_normalization2"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagNameNS |
| var="elemList" |
| obj="doc" |
| namespaceURI='"http://www.w3.org/1999/xhtml"' |
| localName='"code"' |
| interface="Document"/> |
| <item var="element" obj="elemList" interface="NodeList" index="1"/> |
| <firstChild var="childNode" obj="element" interface="Node"/> |
| <nodeValue var="childValue" obj="childNode"/> |
| <assertEquals actual="childValue" expected='"EMP 0001"' ignoreCase="false" id="content2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/infoset04.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset04"> |
| <metadata> |
| <title>infoset04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with infoset = true and see that CDATASection are not present in |
| the parsed document. |
| </description> |
| <date qualifier="created">2004-03-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-infoset"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="pList" type="NodeList"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="pList" obj="doc" tagname='"strong"' interface="Document"/> |
| <item var="elem" obj="pList" index="1" interface="NodeList"/> |
| <lastChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="childIsText"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/infoset05.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset05"> |
| <metadata> |
| <title>infoset05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with infoset = true and see that attributes for namespace declarations are present. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-infoset"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="node" obj="elem" name='"xmlns:dmstc"'/> |
| <assertNotNull actual="node" id="nsAttrNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/infoset06.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset06"> |
| <metadata> |
| <title>infoset06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with infoset and validate = true and check that |
| element content whitespace is not eliminated. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-infoset"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="elemList" type="NodeList"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"validate"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| </if> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <firstChild var="node" obj="elem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="3" ignoreCase="false" id="nodeIsText"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/infoset07.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2001-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset07"> |
| <metadata> |
| <title>infoset07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with infoset = true and see that comments are present in |
| the parsed document. |
| </description> |
| <date qualifier="created">2004-03-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-infoset"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <documentElement var="docElem" obj="doc"/> |
| <previousSibling var="node" obj="docElem" interface="Node"/> |
| <nodeType var="nodeType" obj="node"/> |
| <assertEquals actual="nodeType" expected="8" ignoreCase="false" id="nodeIsDocType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/infoset08.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="infoset08"> |
| <metadata> |
| <title>infoset08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to load a namespace invalid document with infoset = true. |
| </description> |
| <date qualifier="created">2004-03-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-infoset"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"infoset"' value="true"/> |
| <getResourceURI var="resourceURI" href='"namespaces1"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/metadata.xml |
|---|
| 0,0 → 1,19 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE metadata SYSTEM "dom3.dtd"> |
| <!-- This file contains additional metadata about DOM L3 Validation tests. |
| Allowing additional documentation without modifying the tests themselves. --> |
| <metadata xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3"> |
| </metadata> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/namespacedeclarations01.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="namespacedeclarations01"> |
| <metadata> |
| <title>namespacedeclarations01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with namespace-declarations = false and see that attributes |
| for namespace declarations are not present. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespace-declarations"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"namespace-declarations"' value="false"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="node" obj="elem" name='"xmlns:dmstc"'/> |
| <assertNull actual="node" id="nsAttrNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/namespacedeclarations02.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="namespacedeclarations02"> |
| <metadata> |
| <title>namespacedeclarations02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with namespace-declarations = true and see that attributes for namespace declarations are present. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-namespace-declarations"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"namespace-declarations"' value="true"/> |
| <getResourceURI var="resourceURI" href='"hc_staff"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <getElementsByTagName var="elemList" obj="doc" tagname='"p"' interface="Document"/> |
| <item var="elem" obj="elemList" index="0" interface="NodeList"/> |
| <getAttributeNode var="node" obj="elem" name='"xmlns:dmstc"'/> |
| <assertNotNull actual="node" id="nsAttrNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/namespaces01.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="namespaces01"> |
| <metadata> |
| <title>namespaces01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to load a namespace invalid document with namespaces = true. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-namespaces"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"namespaces"' value="true"/> |
| <getResourceURI var="resourceURI" href='"namespaces1"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/namespaces02.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="namespaces02"> |
| <metadata> |
| <title>namespaces02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Attempt to load a namespace invalid document with namespaces = false. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-namespaces"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="node" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="docElem" type="Element"/> |
| <var name="tagName" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"namespaces"' value="false"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"namespaces"' value="false"/> |
| <getResourceURI var="resourceURI" href='"namespaces1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="tagName" obj="docElem"/> |
| <assertEquals actual="tagName" expected='"bad:ns:tag"' ignoreCase="false" id="tagName"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/newline01.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="newline01"> |
| <metadata> |
| <title>newline01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| LSSerializer.newLine should contain the platform default new line. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSSerializer"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-newLine"/> |
| </metadata> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="newLine" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <newLine var="newLine" obj="lsSerializer"/> |
| <assertNotNull actual="newLine" id="newLineNotNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/newline02.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="newline02"> |
| <metadata> |
| <title>newline02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Setting LSSerializer.newLine should change the value retrieved subsequent calls. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSSerializer"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-newLine"/> |
| </metadata> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="newLine" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <newLine obj="lsSerializer" value='"crlf"'/> |
| <newLine var="newLine" obj="lsSerializer"/> |
| <assertEquals actual="newLine" expected='"crlf"' id="newLine" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/newline03.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="newline03"> |
| <metadata> |
| <title>newline03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Setting LSSerializer.newLine to null should reset the default value. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-DOMImplementationLS-createLSSerializer"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-newLine"/> |
| </metadata> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="newLine" type="DOMString"/> |
| <var name="origNewLine" type="DOMString"/> |
| <var name="nullString" type="DOMString" isNull="true"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <newLine var="origNewLine" obj="lsSerializer"/> |
| <newLine obj="lsSerializer" value="nullString"/> |
| <newLine var="newLine" obj="lsSerializer"/> |
| <assertEquals actual="newLine" expected='origNewLine' id="newLine" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/noinputspecified01.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="noinputspecified01"> |
| <metadata> |
| <title>noinputspecified01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parsing using an uninitialized LSInput should result in a PARSE_ERR. |
| is false. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parse"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="lsInput" type="LSInput"/> |
| <var name="nullSchemaLanguage" type="DOMString" isNull="true"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="errorCount" type="int" value="0"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaLanguage"/> |
| <createLSInput var="lsInput" obj="domImplLS"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parse var="doc" obj="lsParser" input="lsInput"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <if><greater actual="severity" expected="1"/> |
| <assertEquals actual="severity" expected="3" id="isFatalError" ignoreCase="false"/> |
| <assertEquals actual="type" expected='"no-input-specified"' id="noInputSpecified" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/nooutputspecified01.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nooutputspecified01"> |
| <metadata> |
| <title>nooutputspecified01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Writing to an uninitialized LSOutput should result in a SERIALIZATION_ERR. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-write"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="lsOutput" type="LSOutput"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="retval" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createLSOutput var="lsOutput" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.w3.org/1999/xhtml"' |
| qualifiedName='"html"' doctype="docType"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <assertLSException id="throw_SERIALIZE_ERR"> |
| <SERIALIZE_ERR> |
| <write var="retval" obj="lsSerializer" nodeArg="doc" destination="lsOutput"/> |
| </SERIALIZE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <if><greater actual="severity" expected="1"/> |
| <assertEquals actual="severity" expected="3" id="isFatalError" ignoreCase="false"/> |
| <assertEquals actual="type" expected='"no-output-specified"' id="noOutputSpecified" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/normalizecharacters01.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters01"> |
| <metadata> |
| <title>normalizecharacters01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parsing a non-Unicode normalized document not have characters normalized if normalize-characters is false. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-normalize-characters"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="nullSchemaLanguage" type="DOMString" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="tagName" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaLanguage"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="false"/> |
| <getResourceURI var="resourceURI" href='"characternormalization1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="tagName" obj="docElem"/> |
| <assertEquals actual="tagName" expected='"suçon"' ignoreCase="false" id="notNormalized"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/normalizecharacters02.xml |
|---|
| 0,0 → 1,54 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters02"> |
| <metadata> |
| <title>normalizecharacters02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parsing a non-Unicode normalized document should result in Unicode-normalized content if normalize-characters is true.. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-normalize-characters"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <var name="nullSchemaLanguage" type="DOMString" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="tagName" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaLanguage"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"normalize-characters"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="true"/> |
| <getResourceURI var="resourceURI" href='"characternormalization1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="docElem" obj="doc"/> |
| <tagName var="tagName" obj="docElem"/> |
| <assertEquals actual="tagName" expected='"suçon"' ignoreCase="false" id="charNormalized"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/normalizecharacters03.xml |
|---|
| 0,0 → 1,52 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters03"> |
| <metadata> |
| <title>normalizecharacters03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Characters should be normalized on serialization if normalize-characters is true. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-normalize-characters"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"normalize-characters"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"suçon"' doctype="docType"/> |
| <documentElement var="docElem" obj="doc"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="true"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertTrue id="notNormalized"><contains obj="output" str='"suçon"' interface="DOMString"/></assertTrue> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/normalizecharacters04.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="normalizecharacters04"> |
| <metadata> |
| <title>normalizecharacters04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Characters should be not normalized on serialization if normalize-characters is false. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-normalize-characters"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="output" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"suçon"' doctype="docType"/> |
| <documentElement var="docElem" obj="doc"/> |
| <setParameter obj="domConfig" name='"normalize-characters"' value="false"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertTrue id="notNormalized"><contains obj="output" str='"suçon"' interface="DOMString"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/schemalocation01.xml |
|---|
| 0,0 → 1,70 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="schemalocation01"> |
| <metadata> |
| <title>schemalocation01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Validate a document with no DTD against an externally specified schema that matches its content. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-location"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetSchemaType" type="boolean"/> |
| <var name="canSetSchemaLocation" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetSchemaType" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"validateschema1"' contentType="text/xml"/> |
| <canSetParameter var="canSetSchemaLocation" obj="domConfig" name='"schema-location"' value="resourceURI"/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetSchemaType"/> |
| <isTrue value="canSetSchemaLocation"/> |
| </and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"schema-location"' value="resourceURI"/> |
| <getResourceURI var="resourceURI" href='"validate1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="elem" obj="doc"/> |
| <assertNotNull actual="elem" id="docElemNotNull"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"elt0"' ignoreCase="false" id="docElemName"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/schemalocation02.xml |
|---|
| 0,0 → 1,83 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="schemalocation02"> |
| <metadata> |
| <title>schemalocation02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Validate a document with no DTD against an externally specified schema that does not match its content. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-location"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetSchemaType" type="boolean"/> |
| <var name="canSetSchemaLocation" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetSchemaType" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"validateschema1"' contentType="text/xml"/> |
| <canSetParameter var="canSetSchemaLocation" obj="domConfig" name='"schema-location"' value="resourceURI"/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetSchemaType"/> |
| <isTrue value="canSetSchemaLocation"/> |
| </and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"schema-location"' value="resourceURI"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"test3"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <if><equals actual="severity" expected="2" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertTrue id="atLeastOneError"><greater actual="errorCount" expected="0"/></assertTrue> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/schemalocation03.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="schemalocation03"> |
| <metadata> |
| <title>schemalocation03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Serialize a document with no DTD against an externally specified schema that matches its content. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-location"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetSchemaType" type="boolean"/> |
| <var name="canSetSchemaLocation" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <var name="doctype" type="DocumentType" isNull="true"/> |
| <var name="output" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetSchemaType" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"validateschema1"' contentType="text/xml"/> |
| <canSetParameter var="canSetSchemaLocation" obj="domConfig" name='"schema-location"' value="resourceURI"/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetSchemaType"/> |
| <isTrue value="canSetSchemaLocation"/> |
| </and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"schema-location"' value="resourceURI"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI="nullNS" qualifiedName='"elt0"' doctype="doctype"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/schemalocation04.xml |
|---|
| 0,0 → 1,71 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="schemalocation04"> |
| <metadata> |
| <title>schemalocation04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Serialize a document with no DTD against an externally specified schema that matches its content. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-location"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetSchemaType" type="boolean"/> |
| <var name="canSetSchemaLocation" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <var name="doctype" type="DocumentType" isNull="true"/> |
| <var name="output" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetSchemaType" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"validateschema1"' contentType="text/xml"/> |
| <canSetParameter var="canSetSchemaLocation" obj="domConfig" name='"schema-location"' value="resourceURI"/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetSchemaType"/> |
| <isTrue value="canSetSchemaLocation"/> |
| </and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"schema-location"' value="resourceURI"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI="nullNS" qualifiedName='"elt2"' doctype="doctype"/> |
| <assertLSException id="throw_SERIALIZE_ERR"> |
| <SERIALIZE_ERR> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </SERIALIZE_ERR> |
| </assertLSException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/schematype01.xml |
|---|
| 0,0 → 1,74 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="schematype01"> |
| <metadata> |
| <title>schematype01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Specify schema validation for a document with a DTD but no specified schema. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetSchemaType" type="boolean"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetSchemaType" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetSchemaType"/> |
| </and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"test3"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <if><equals actual="severity" expected="2" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertTrue id="atLeastOneError"><greater actual="errorCount" expected="0"/></assertTrue> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/schematype02.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="schematype02"> |
| <metadata> |
| <title>schematype02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Specify DTD validation for a document with a matching DTD. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetSchemaType" type="boolean"/> |
| <var name="dtdNS" type="DOMString" value='"http://www.w3.org/TR/REC-xml"'/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetSchemaType" obj="domConfig" name='"schema-type"' value='dtdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetSchemaType"/> |
| </and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='dtdNS'/> |
| <getResourceURI var="resourceURI" href='"test3"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="elem" obj="doc"/> |
| <assertNotNull actual="elem" id="docElemNotNull"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"elt0"' ignoreCase="false" id="docElemName"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/schematype03.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="schematype03"> |
| <metadata> |
| <title>schematype03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Specify schema validation for a document with no DTD but schema location hints. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetSchemaType" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetSchemaType" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetSchemaType"/> |
| </and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <getResourceURI var="resourceURI" href='"schematype1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="elem" obj="doc"/> |
| <assertNotNull actual="elem" id="docElemNotNull"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"elt0"' ignoreCase="false" id="docElemName"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/schematype04.xml |
|---|
| 0,0 → 1,65 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="schematype04"> |
| <metadata> |
| <title>schematype04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Serialize a document with schema validation but no available schema. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-schema-type"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="canSetValidate" type="boolean"/> |
| <var name="canSetSchemaType" type="boolean"/> |
| <var name="xsdNS" type="DOMString" value='"http://www.w3.org/2001/XMLSchema"'/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <var name="doctype" type="DocumentType" isNull="true"/> |
| <var name="output" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <canSetParameter var="canSetValidate" obj="domConfig" name='"validate"' value="true"/> |
| <canSetParameter var="canSetSchemaType" obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <if> |
| <and> |
| <isTrue value="canSetValidate"/> |
| <isTrue value="canSetSchemaType"/> |
| </and> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"schema-type"' value='xsdNS'/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI="nullNS" qualifiedName='"elt0"' doctype="doctype"/> |
| <assertLSException id="throw_SERIALIZE_ERR"> |
| <SERIALIZE_ERR> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </SERIALIZE_ERR> |
| </assertLSException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/splitcdatasections01.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="splitcdatasections01"> |
| <metadata> |
| <title>splitcdatasections01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| CDATASections containing unrepresentable characters should be split when split-cdata-sections is true. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-split-cdata-sections"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createCDATASection var="newNode" obj="doc" data='"this is not ]]> good"'/> |
| <appendChild var="retNode" obj="docElem" newChild="newNode"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"split-cdata-sections"' value="true"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="true"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertFalse id="notNaive"><contains obj="output" str='"this is not ]]> good"' interface="DOMString"/></assertFalse> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/splitcdatasections02.xml |
|---|
| 0,0 → 1,76 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="splitcdatasections02"> |
| <metadata> |
| <title>splitcdatasections02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| CDATASections containing unrepresentable characters raise a SERIALIZE_ERR when |
| split-cdata-sections is false and well-formed is true. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-split-cdata-sections"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-well-formed"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="docElem" type="Element"/> |
| <var name="newNode" type="Node"/> |
| <var name="output" type="DOMString"/> |
| <var name="retNode" type="Node"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="errorCount" type="int" value="0"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <documentElement var="docElem" obj="doc"/> |
| <createCDATASection var="newNode" obj="doc" data='"this is not ]]> good"'/> |
| <appendChild var="retNode" obj="docElem" newChild="newNode"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"split-cdata-sections"' value="false"/> |
| <setParameter obj="domConfig" name='"cdata-sections"' value="true"/> |
| <setParameter obj="domConfig" name='"well-formed"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <assertLSException id="throw_SERIALIZE_ERR"> |
| <SERIALIZE_ERR> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </SERIALIZE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <if><equals actual="type" expected='"wf-invalid-character"' ignoreCase="false"/> |
| <assertEquals actual="severity" expected="2" ignoreCase="false" id="severityError"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertTrue id="hasWfErrors"><greater actual="errorCount" expected="0"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/unsupportedencoding01.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="unsupportedencoding01"> |
| <metadata> |
| <title>checkcharacternormalization02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Parsing a document with a unsupported encoding should raise a PARSE_ERR and dispatch a "unsupported-encoding" |
| DOM error. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="nullSchemaLanguage" type="DOMString" isNull="true"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <var name="errorCount" type="int" value="0"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaLanguage"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"unsupportedencoding1"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <type var="type" obj="error" interface="DOMError"/> |
| <if><equals actual="type" expected='"unsupported-encoding"' ignoreCase="true"/> |
| <assertEquals actual="severity" expected="3" id="isError" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validate01.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validate01"> |
| <metadata> |
| <title>validate01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document without a DTD with validate=false, should load without complaint. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"validate"' value="false"/> |
| <getResourceURI var="resourceURI" href='"test0"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="elem" obj="doc"/> |
| <assertNotNull actual="elem" id="docElemNotNull"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"elt0"' ignoreCase="false" id="docElemName"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validate02.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validate02"> |
| <metadata> |
| <title>validate02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document without a DTD with validate=true, should throw PARSE_ERR. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"validate"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"test0"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <if><equals actual="severity" expected="2" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertTrue id="atLeastOneError"><greater actual="errorCount" expected="0"/></assertTrue> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validate03.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validate03"> |
| <metadata> |
| <title>validate03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with a DTD that doesn't match content with validate=false, should load without complaint. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"validate"' value="false"/> |
| <getResourceURI var="resourceURI" href='"validate1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="elem" obj="doc"/> |
| <assertNotNull actual="elem" id="docElemNotNull"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"elt0"' ignoreCase="false" id="docElemName"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validate04.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validate04"> |
| <metadata> |
| <title>validate04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with mismatched DTD with validate=true, should throw PARSE_ERR. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"validate"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"validate1"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <if><equals actual="severity" expected="2" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertTrue id="atLeastOneError"><greater actual="errorCount" expected="0"/></assertTrue> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validate05.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validate05"> |
| <metadata> |
| <title>validate05</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| A document without a DTD should serialize without complaint if validate is false. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="output" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"validate"' value="false"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validate06.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validate06"> |
| <metadata> |
| <title>validate06</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| A document without a DTD should throw a SERIALIZE_ERR if validate is true. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="output" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"validate"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <assertLSException id="throw_SERIALIZE_ERR"> |
| <SERIALIZE_ERR> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </SERIALIZE_ERR> |
| </assertLSException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validate07.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validate07"> |
| <metadata> |
| <title>validate07</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load and serialize a document with a DTD that doesn't match content with validate=false, should load and serialize without complaint. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="output" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"validate"' value="false"/> |
| <getResourceURI var="resourceURI" href='"validate1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="elem" obj="doc"/> |
| <assertNotNull actual="elem" id="docElemNotNull"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"elt0"' ignoreCase="false" id="docElemName"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"validate"' value="false"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validate08.xml |
|---|
| 0,0 → 1,59 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validate08"> |
| <metadata> |
| <title>validate08</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with a DTD that doesn't match content, then attempt to serialize when validate is true which |
| should result in a SERIALIZE_ERR. |
| </description> |
| <date qualifier="created">2004-04-01</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="output" type="DOMString"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"validate"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"validate"' value="true"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"validate"' value="false"/> |
| <getResourceURI var="resourceURI" href='"validate1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertLSException id="throw_SERIALIZE_ERR"> |
| <SERIALIZE_ERR> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| </SERIALIZE_ERR> |
| </assertLSException> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validateifschema01.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validateifschema01"> |
| <metadata> |
| <title>validateifschema01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document without a DTD with validate-if-schema=false, should load without complaint. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate-if-schema"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"validate-if-schema"' value="false"/> |
| <getResourceURI var="resourceURI" href='"test0"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="elem" obj="doc"/> |
| <assertNotNull actual="elem" id="docElemNotNull"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"elt0"' ignoreCase="false" id="docElemName"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validateifschema02.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validateifschema02"> |
| <metadata> |
| <title>validateifschema02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document without a DTD with validate-if-schema=true should successfully complete. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate-if-schema"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="canSet" type="boolean"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"validate-if-schema"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"validate-if-schema"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"test0"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <assertLowerSeverity id="noErrors" obj="errorMonitor" severity="SEVERITY_ERROR"/> |
| <documentElement var="elem" obj="doc"/> |
| <assertNotNull actual="elem" id="docElemNotNull"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"elt0"' ignoreCase="false" id="docElemName"/> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validateifschema03.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validateifschema03"> |
| <metadata> |
| <title>validateifschema03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with a DTD that doesn't match content with validate-if-schema=false, should load without complaint. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate-if-schema"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"validate-if-schema"' value="false"/> |
| <getResourceURI var="resourceURI" href='"validate1"' contentType="text/xml"/> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| <assertNotNull actual="doc" id="docNotNull"/> |
| <documentElement var="elem" obj="doc"/> |
| <assertNotNull actual="elem" id="docElemNotNull"/> |
| <nodeName var="nodeName" obj="elem"/> |
| <assertEquals actual="nodeName" expected='"elt0"' ignoreCase="false" id="docElemName"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/validateifschema04.xml |
|---|
| 0,0 → 1,67 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validateifschema04"> |
| <metadata> |
| <title>validateifschema04</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with mismatched DTD with validate-if-schema=true, should throw PARSE_ERR. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-validate-if-schema"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="canSet" type="boolean"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <canSetParameter var="canSet" obj="domConfig" name='"validate-if-schema"' value="true"/> |
| <if><isTrue value="canSet"/> |
| <setParameter obj="domConfig" name='"validate-if-schema"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"validate1"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <severity var="severity" obj="error"/> |
| <if><equals actual="severity" expected="2" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertTrue id="atLeastOneError"><greater actual="errorCount" expected="0"/></assertTrue> |
| </if> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/wellformed01.xml |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="wellformed01"> |
| <metadata> |
| <title>wellformed01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with an invalid character in a tagname. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-well-formed"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"well-formed"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"wellformed1"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <type interface="DOMError" var="type" obj="error"/> |
| <severity var="severity" obj="error"/> |
| <if><greater actual="severity" expected="1"/> |
| <assertEquals actual="type" expected='"wf-invalid-character-in-node-name"' ignoreCase="false" id="type"/> |
| <assertEquals actual="severity" expected="2" id="severityError" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneWFError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/wellformed02.xml |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="wellformed02"> |
| <metadata> |
| <title>wellformed02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with an invalid character in an attribute name. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-well-formed"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"well-formed"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"wellformed2"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <type interface="DOMError" var="type" obj="error"/> |
| <severity var="severity" obj="error"/> |
| <if><greater actual="severity" expected="1"/> |
| <assertEquals actual="type" expected='"wf-invalid-character-in-node-name"' ignoreCase="false" id="type"/> |
| <assertEquals actual="severity" expected="2" id="severityError" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneWFError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/wellformed03.xml |
|---|
| 0,0 → 1,68 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="wellformed03"> |
| <metadata> |
| <title>wellformed03</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Load a document with an invalid character in an attribute value, should throw a PARSE_ERR and |
| dispatch a DOMError with type 'wf-invalid-character'. |
| </description> |
| <date qualifier="created">2004-03-29</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSParser-parseURI"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core#parameter-well-formed"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="Element"/> |
| <var name="node" type="Node"/> |
| <var name="nodeName" type="DOMString"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsParser" type="LSParser"/> |
| <var name="nullSchemaType" type="DOMString" isNull="true"/> |
| <var name="resourceURI" type="DOMString"/> |
| <var name="errorMonitor" type="DOMErrorMonitor"/> |
| <var name="errors" type="List"/> |
| <var name="error" type="DOMError"/> |
| <var name="errorCount" type="int" value="0"/> |
| <var name="severity" type="int"/> |
| <var name="type" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSParser var="lsParser" obj="domImplLS" mode="1" schemaType="nullSchemaType"/> |
| <domConfig obj="lsParser" var="domConfig" interface="LSParser"/> |
| <setParameter obj="domConfig" name='"well-formed"' value="true"/> |
| <setParameter obj="domConfig" name='"error-handler"' value="errorMonitor"/> |
| <getResourceURI var="resourceURI" href='"wellformed3"' contentType="text/xml"/> |
| <assertLSException id="throw_PARSE_ERR"> |
| <PARSE_ERR> |
| <parseURI var="doc" obj="lsParser" uri="resourceURI"/> |
| </PARSE_ERR> |
| </assertLSException> |
| <allErrors var="errors" obj="errorMonitor"/> |
| <for-each member="error" collection="errors"> |
| <type interface="DOMError" var="type" obj="error"/> |
| <severity var="severity" obj="error"/> |
| <if><equals actual="type" expected='"wf-invalid-character"' ignoreCase="false"/> |
| <assertEquals actual="severity" expected="2" id="severityError" ignoreCase="false"/> |
| <increment var="errorCount" value="1"/> |
| </if> |
| </for-each> |
| <assertEquals actual="errorCount" expected="1" ignoreCase="false" id="oneWFError"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/writeToURI1.xml |
|---|
| 0,0 → 1,69 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="writeToURI1"> |
| <metadata> |
| <title>writeToURI1</title> |
| <creator>Curt Arnold</creator> |
| <description>Writes a document to a URL for a temporary file |
| using LSSerializer.writeToURI and rereads the document.</description> |
| <date qualifier="created">2003-12-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToURI"/> |
| </metadata> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="testDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="output" type="LSOutput"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="systemId" type="DOMString"/> |
| <var name="checkSystemId" type="DOMString"/> |
| <var name="status" type="boolean"/> |
| <var name="input" type="LSInput"/> |
| <var name="parser" type="LSParser"/> |
| <var name="checkDoc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemName" type="DOMString"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <load var="testDoc" href="test0" willBeModified="false"/> |
| <implementation var="domImpl"/> |
| <createTempURI var="systemId" scheme="file"/> |
| <!-- create a serializer and write a test document --> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <writeToURI var="status" obj="serializer" nodeArg="testDoc" uri="systemId"/> |
| <assertTrue actual="status" id="writeStatus"/> |
| <!-- read the serialized document --> |
| <createLSInput var="input" obj="domImpl"/> |
| <systemId obj="input" value="systemId" interface="LSInput"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <parse var="checkDoc" obj="parser" input="input"/> |
| <assertNotNull actual="checkDoc" id="checkNotNull"/> |
| <documentElement var="docElem" obj="checkDoc"/> |
| <nodeName var="docElemName" obj="docElem"/> |
| <assertEquals expected='"elt0"' actual="docElemName" id="checkDocElemName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/writeToURI2.xml |
|---|
| 0,0 → 1,69 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="writeToURI2"> |
| <metadata> |
| <title>writeToURI2</title> |
| <creator>Curt Arnold</creator> |
| <description>Writes a document to a URL for a http server |
| using LSSerializer.writeToURI and rereads the document.</description> |
| <date qualifier="created">2003-12-30</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToURI"/> |
| </metadata> |
| <implementationAttribute name="validating" value="false"/> |
| <var name="testDoc" type="Document"/> |
| <var name="domImpl" type="DOMImplementationLS"/> |
| <var name="output" type="LSOutput"/> |
| <var name="serializer" type="LSSerializer"/> |
| <var name="systemId" type="DOMString"/> |
| <var name="checkSystemId" type="DOMString"/> |
| <var name="status" type="boolean"/> |
| <var name="input" type="LSInput"/> |
| <var name="parser" type="LSParser"/> |
| <var name="checkDoc" type="Document"/> |
| <var name="docElem" type="Element"/> |
| <var name="docElemName" type="DOMString"/> |
| <var name="NULL_SCHEMA_TYPE" type="DOMString" isNull="true"/> |
| <load var="testDoc" href="test0" willBeModified="false"/> |
| <implementation var="domImpl"/> |
| <createTempURI var="systemId" scheme="http"/> |
| <!-- create a serializer and write a test document --> |
| <createLSSerializer var="serializer" obj="domImpl"/> |
| <writeToURI var="status" obj="serializer" nodeArg="testDoc" uri="systemId"/> |
| <assertTrue actual="status" id="writeStatus"/> |
| <!-- read the serialized document --> |
| <createLSInput var="input" obj="domImpl"/> |
| <systemId obj="input" value="systemId" interface="LSInput"/> |
| <createLSParser var="parser" obj="domImpl" schemaType="NULL_SCHEMA_TYPE" mode="1"/> |
| <parse var="checkDoc" obj="parser" input="input"/> |
| <assertNotNull actual="checkDoc" id="checkNotNull"/> |
| <documentElement var="docElem" obj="checkDoc"/> |
| <nodeName var="docElemName" obj="docElem"/> |
| <assertEquals expected='"elt0"' actual="docElemName" id="checkDocElemName" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/xmldeclaration01.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="xmldeclaration01"> |
| <metadata> |
| <title>xmldeclaration01</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| XML declarations should be serialized if xml-declaration is true. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-xml-declaration"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="output" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"xml-declaration"' value="true"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertTrue id="containsXMLDecl"><contains obj="output" str='"<?xml"' interface="DOMString"/></assertTrue> |
| <assertTrue id="containsUTF16"><contains obj="output" str='"UTF-16"' interface="DOMString"/></assertTrue> |
| <assertTrue id="contains1_0"><contains obj="output" str='"1.0"' interface="DOMString"/></assertTrue> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/ls/xmldeclaration02.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="xmldeclaration02"> |
| <metadata> |
| <title>xmldeclaration02</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| XML declarations should not be serialized if xml-declaration is false. |
| </description> |
| <date qualifier="created">2004-03-31</date> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#LS-LSSerializer-writeToString"/> |
| <subject resource="http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save#parameter-xml-declaration"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="domConfig" type="DOMConfiguration"/> |
| <var name="domImplLS" type="DOMImplementationLS"/> |
| <var name="lsSerializer" type="LSSerializer"/> |
| <var name="docType" type="DocumentType" isNull="true"/> |
| <var name="output" type="DOMString"/> |
| <implementation var="domImplLS"/> |
| <createLSSerializer var="lsSerializer" obj="domImplLS"/> |
| <createDocument var="doc" obj="domImplLS" namespaceURI='"http://www.example.org"' |
| qualifiedName='"test"' doctype="docType"/> |
| <domConfig obj="lsSerializer" var="domConfig" interface="LSSerializer"/> |
| <setParameter obj="domConfig" name='"xml-declaration"' value="false"/> |
| <writeToString var="output" obj="lsSerializer" nodeArg="doc"/> |
| <assertFalse id="containsXMLDecl"><contains obj="output" str='"<?xml"' interface="DOMString"/></assertFalse> |
| <assertFalse id="containsUTF16"><contains obj="output" str='"UTF-16"' interface="DOMString"/></assertFalse> |
| <assertFalse id="contains1_0"><contains obj="output" str='"1.0"' interface="DOMString"/></assertFalse> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/.cvsignore |
|---|
| 0,0 → 1,3 |
| dom3.dtd |
| dom3.xsd |
| test-to-html.xsl |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/CVS/Entries |
|---|
| 0,0 → 1,47 |
| D/files//// |
| /.cvsignore/1.1/Fri Apr 3 02:47:58 2009// |
| /allowedAttributes.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /allowedChildren.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /allowedFirstChildren.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /allowedNextSiblings.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /allowedParents.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /allowedPreviousSiblings.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /alltests.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /canAppendChildFalse.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canAppendChildTrue.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canAppendData.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canDeleteData.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canInsertBeforeFalse.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canInsertBeforeTrue.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canInsertData.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canRemoveAttributeFalse.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /canRemoveAttributeNS.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canRemoveAttributeNode.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /canRemoveAttributeTrue.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /canRemoveChildFalse.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /canRemoveChildTrue.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /canReplaceChildFalse.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canReplaceChildTrue.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canReplaceDataFalse.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canReplaceDataTrue.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canSetAttributeFalse.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /canSetAttributeNS.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /canSetAttributeNode.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /canSetAttributeTrue.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /canSetData.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /contentType.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /defaultValue.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /definedElements.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /enumeratedValues.xml/1.5/Fri Apr 3 02:47:58 2009// |
| /getFeature01.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /getFeature02.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /hasFeature01.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /hasFeature02.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /hasFeature03.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /hasFeature04.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /isElementDefined.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /isElementDefinedNS.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /metadata.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /nodeValidity.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /requiredAttributes.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /validateDocument.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/validation |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/CVS/Template |
|---|
| --- test/testcases/tests/level3/validation/allowedAttributes.xml (nonexistent) |
| +++ test/testcases/tests/level3/validation/allowedAttributes.xml (revision 4364) |
| @@ -0,0 +1,45 @@ |
| +<?xml version="1.0" encoding="UTF-8"?> |
| +<?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| + |
| +<!-- |
| + |
| +Copyright (c) 2003 Oracle |
| + |
| +All Rights Reserved. This program is distributed under the W3C's |
| +Software Intellectual Property License [1]. This program is distributed |
| +in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| +even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| +PURPOSE. |
| + |
| +[1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| + |
| +--> |
| + |
| +<!DOCTYPE test SYSTEM "dom3.dtd"> |
| +<test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="allowedAttributes"> |
| +<metadata> |
| + |
| +<title>allowedAttributes</title> |
| +<creator>Kongyi Zhou</creator> |
| +<description> |
| + The method getAllowedAttributes returns the NameList of allowed attributes for |
| + the element. |
| +</description> |
| +<contributor>Oracle Corp.</contributor> |
| +<date qualifier="created">2003-03-01</date> |
| +<subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#ElementEditVAL-allowedAttributes"/> |
| +</metadata> |
| +<implementationAttribute name="schemaValidating" value="true"/> |
| + |
| +<var name="doc" type="Document"/> |
| +<var name="root" type="ElementEditVAL"/> |
| +<var name="attrlist" type="NameList"/> |
| +<var name="attname" type="DOMString"/> |
| +<var name="allowedAttributesLength" type="int"/> |
| +<load var="doc" href="book" willBeModified="false"/> |
| +<documentElement obj="doc" var="root"/> |
| +<allowedAttributes obj="root" var="attrlist"/> |
| +<assertNotNull actual="attrlist" id="allowedAttributesNotNull"/> |
| +<length var="allowedAttributesLength" obj="attrlist" interface="NameList"/> |
| +<assertEquals actual="allowedAttributesLength" expected="2" id="allowedAttributes" ignoreCase="false"/> |
| +</test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/allowedChildren.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="allowedChildren"> |
| <metadata> |
| <title>allowedChildren</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method getAllowedChildren returns the NameList of allowed child elements. |
| should return NameList of length 7 |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#ElementEditVAL-allowedChildren"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="nlist" type="NameList"/> |
| <var name="allowedChildrenLength" type="int"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <allowedChildren obj="root" var="nlist"/> |
| <assertNotNull actual="nlist" id="allowedChildrenNotNull"/> |
| <length var="allowedChildrenLength" obj="nlist" interface="NameList"/> |
| <assertEquals actual="allowedChildrenLength" expected="7" id="allowedChildren" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/allowedFirstChildren.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="allowedFirstChildren"> |
| <metadata> |
| <title>allowedFirstChildren</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method getAllowedFirstChildren returns the NameList of allowed first child elements. |
| should return NameList containing name 'title'. |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#ElementEditVAL-allowedFirstChildElements"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="nlist" type="NameList"/> |
| <var name="childname" type="DOMString"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <allowedFirstChildren obj="root" var="nlist"/> |
| <assertNotNull actual="nlist" id="allowedFirstChildrenNotNull"/> |
| <getName interface="NameList" obj="nlist" index="0" var="childname"/> |
| <assertEquals actual="childname" expected='"title"' ignoreCase="false" id="allowedFirstChildren"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/allowedNextSiblings.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="allowedNextSiblings"> |
| <metadata> |
| <title>allowedNextSiblings</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method getAllowedNextSiblings return the NameList of elements that may be |
| inserted, should return empty list. |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#ElementEditVAL-allowedNextSiblings"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="ElementEditVAL"/> |
| <var name="nlist" type="NameList"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="childname" type="DOMString"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName obj="doc" interface="Document" var="elemList" tagname='"author"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <allowedNextSiblings obj="elem" var="nlist"/> |
| <assertNotNull actual="nlist" id="allowedNextSiblingsNotNull"/> |
| <getName interface="NameList" obj="nlist" index="0" var="childname"/> |
| <!-- since ISBN is already present, no insertable sibling --> |
| <assertNull actual="childname" id="noAllowableNextSibling"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/allowedParents.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="allowedParents"> |
| <metadata> |
| <title>allowedParents</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method getAllowedParents returns the NameList of elements that may be the |
| the parent of current node |
| should return NameList containing name 'book'. |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#ElementEditVAL-allowedParents"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="ElementEditVAL"/> |
| <var name="nlist" type="NameList"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="childname" type="DOMString"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName obj="doc" interface="Document" var="elemList" tagname='"author"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <allowedParents obj="elem" var="nlist"/> |
| <assertNotNull actual="nlist" id="allowedParentsNotNull"/> |
| <getName interface="NameList" obj="nlist" index="0" var="childname"/> |
| <assertEquals actual="childname" expected='"book"' ignoreCase="false" id="allowedParents"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/allowedPreviousSiblings.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="allowedPreviousSiblings"> |
| <metadata> |
| <title>allowedPreviousSiblings</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method getAllowedPreviousSiblings return the NameList of elements that may be the |
| previous siblings, should return empty list. |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#ElementEditVAL-allowedPreviousSiblings"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="ElementEditVAL"/> |
| <var name="nlist" type="NameList"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="childname" type="DOMString"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName obj="doc" interface="Document" var="elemList" tagname='"author"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <allowedPreviousSiblings obj="elem" var="nlist"/> |
| <assertNotNull actual="nlist" id="allowedPreviousSiblingsNotNull"/> |
| <getName interface="NameList" obj="nlist" index="0" var="childname"/> |
| <assertNull actual="childname" id="noPreviousSiblings"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/alltests.xml |
|---|
| 0,0 → 1,69 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE suite SYSTEM "dom3.dtd"> |
| <suite xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="alltests"> |
| <metadata> |
| <title>DOM Level 3 Validation Test Suite</title> |
| <creator>DOM Test Suite Project</creator> |
| </metadata> |
| <suite.member href="allowedAttributes.xml"/> |
| <suite.member href="allowedChildren.xml"/> |
| <suite.member href="allowedFirstChildren.xml"/> |
| <suite.member href="allowedNextSiblings.xml"/> |
| <suite.member href="allowedParents.xml"/> |
| <suite.member href="allowedPreviousSiblings.xml"/> |
| <suite.member href="canAppendChildFalse.xml"/> |
| <suite.member href="canAppendChildTrue.xml"/> |
| <suite.member href="canAppendData.xml"/> |
| <suite.member href="canDeleteData.xml"/> |
| <suite.member href="canInsertBeforeFalse.xml"/> |
| <suite.member href="canInsertBeforeTrue.xml"/> |
| <suite.member href="canInsertData.xml"/> |
| <suite.member href="canRemoveAttributeFalse.xml"/> |
| <suite.member href="canRemoveAttributeNS.xml"/> |
| <suite.member href="canRemoveAttributeNode.xml"/> |
| <suite.member href="canRemoveAttributeTrue.xml"/> |
| <suite.member href="canRemoveChildFalse.xml"/> |
| <suite.member href="canRemoveChildTrue.xml"/> |
| <suite.member href="canReplaceChildFalse.xml"/> |
| <suite.member href="canReplaceChildTrue.xml"/> |
| <suite.member href="canReplaceDataFalse.xml"/> |
| <suite.member href="canReplaceDataTrue.xml"/> |
| <suite.member href="canSetAttributeFalse.xml"/> |
| <suite.member href="canSetAttributeNS.xml"/> |
| <suite.member href="canSetAttributeNode.xml"/> |
| <suite.member href="canSetAttributeTrue.xml"/> |
| <suite.member href="canSetData.xml"/> |
| <suite.member href="contentType.xml"/> |
| <suite.member href="defaultValue.xml"/> |
| <suite.member href="definedElements.xml"/> |
| <suite.member href="enumeratedValues.xml"/> |
| <suite.member href="isElementDefined.xml"/> |
| <suite.member href="isElementDefinedNS.xml"/> |
| <suite.member href="nodeValidity.xml"/> |
| <suite.member href="requiredAttributes.xml"/> |
| <suite.member href="validateDocument.xml"/> |
| <suite.member href="hasFeature01.xml"/> |
| <suite.member href="hasFeature02.xml"/> |
| <suite.member href="hasFeature03.xml"/> |
| <suite.member href="hasFeature04.xml"/> |
| <suite.member href="getFeature01.xml"/> |
| <suite.member href="getFeature02.xml"/> |
| </suite> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canAppendChildFalse.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canAppendChildFalse"> |
| <metadata> |
| <title>canAppendChildFalse</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canAppendChild checks with schema to see if the child node can be appended |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-NodeEditVAL-canAppendChild"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="newchild" type="Element"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <createElementNS obj="doc" interface="Document" namespaceURI="nullNS" qualifiedName='"editor"' var="newchild"/> |
| <canAppendChild obj="root" newChild="newchild" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canAppendChildFalse"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canAppendChildTrue.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canAppendChildTrue"> |
| <metadata> |
| <title>canAppendChildTrue</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canAppendChild checks with schema to see if the child node can be appended |
| should return VAL_TRUE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-NodeEditVAL-canAppendChild"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="newchild" type="Element"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <createElementNS obj="doc" interface="Document" namespaceURI="nullNS" qualifiedName='"year"' var="newchild"/> |
| <canAppendChild obj="root" newChild="newchild" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="5" ignoreCase="false" id="canAppendChildTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canAppendData.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canAppendData"> |
| <metadata> |
| <title>canAppendData</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method checks if given charactors can be appended |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-CharacterDataEditVAL-canAppendData"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="valboolean" type="short"/> |
| <var name="chars" type="CharacterDataEditVAL"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName obj="doc" interface="Document" var="elemList" tagname='"edition"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <firstChild interface="Node" obj="elem" var="chars"/> |
| <canAppendData obj="chars" arg='"USD60"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canAppendData"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canDeleteData.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canDeleteData"> |
| <metadata> |
| <title>canDeleteData</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method checks if given characters can be deleted from exitsting text |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-CharacterDataEditVAL-canDeleteData"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="valboolean" type="short"/> |
| <var name="chars" type="CharacterDataEditVAL"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName obj="doc" interface="Document" var="elemList" tagname='"edition"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <firstChild interface="Node" obj="elem" var="chars"/> |
| <canDeleteData obj="chars" offset="0" count="10" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canDeleteData"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canInsertBeforeFalse.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canInsertBeforeFalse"> |
| <metadata> |
| <title>canInsertBeforeFalse</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canInsertBefore checks with schema to see if a new child can be inserted |
| before reference node |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-NodeEditVAL-canInsertBefore"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="oldchild" type="Node"/> |
| <var name="nlist" type="NodeList"/> |
| <var name="newchild" type="Element"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"ISBN"' var="nlist"/> |
| <item obj="nlist" index="0" var="oldchild" interface="NodeList"/> |
| <documentElement obj="doc" var="root"/> |
| <createElementNS obj="doc" namespaceURI="nullNS" qualifiedName='"editor"' var="newchild"/> |
| <canInsertBefore obj="root" newChild="newchild" refChild="oldchild" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canInsertBeforeFalse"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canInsertBeforeTrue.xml |
|---|
| 0,0 → 1,51 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canInsertBeforeTrue"> |
| <metadata> |
| <title>canInsertBeforeTrue</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canInsertBefore checks with schema to see if a new child can be inserted |
| before reference node |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-NodeEditVAL-canInsertBefore"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="oldchild" type="Node"/> |
| <var name="refchild" type="Node"/> |
| <var name="nlist" type="NodeList"/> |
| <var name="newchild" type="Element"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"ISBN"' var="nlist"/> |
| <item obj="nlist" index="0" var="refchild" interface="NodeList"/> |
| <documentElement obj="doc" var="root"/> |
| <createElementNS obj="doc" namespaceURI="nullNS" qualifiedName='"editor"' var="newchild"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"author"' var="nlist"/> |
| <item obj="nlist" index="0" var="oldchild" interface="NodeList"/> |
| <removeChild obj="root" oldChild="oldchild" var="oldchild"/> |
| <canInsertBefore obj="root" newChild="newchild" refChild="refchild" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="5" ignoreCase="false" id="canInsertBeforeTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canInsertData.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canInsertData"> |
| <metadata> |
| <title>canInsertData</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method checks if given characters can be inserted into exitsting text |
| at given position |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-CharacterDataEditVAL-canInsertData"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="valboolean" type="short"/> |
| <var name="chars" type="CharacterDataEditVAL"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName obj="doc" interface="Document" var="elemList" tagname='"edition"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <firstChild interface="Node" obj="elem" var="chars"/> |
| <canInsertData obj="chars" offset="0" arg='"USD60"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canInsertData"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canRemoveAttributeFalse.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canRemoveAttributeFalse"> |
| <metadata> |
| <title>canRemoveAttributeFalse</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canSteAttribute checks if the 'inStock' attribute can be removed |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-canRemoveAttribute"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <canRemoveAttribute obj="root" attrname='"inStock"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canRemoveAttributeFalse"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canRemoveAttributeNS.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canRemoveAttributeNS"> |
| <metadata> |
| <title>canRemoveAttributeNS</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method checks if the attribute with given namesapce and name can be removed |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-canRemoveAttributeNS"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <canRemoveAttributeNS obj="root" namespaceURI="nullNS" localName='"inStock"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canRemoveAttributeNS"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canRemoveAttributeNode.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canRemoveAttributeNode"> |
| <metadata> |
| <title>canRemoveAttribute</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canRemoveAttributeNode checks if given attribute node can be removed |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-canRemoveAttributeNode"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="attr" type="Attr"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <getAttributeNode obj="root" name='"inStock"' var="attr"/> |
| <canRemoveAttributeNode obj="root" attrNode="attr" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canRemoveAttributeNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canRemoveAttributeTrue.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canRemoveAttributeTrue"> |
| <metadata> |
| <title>canRemoveAttributeTrue</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canSteAttribute checks if the 'price' attribute can be removed |
| should return VAL_TRUE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-canRemoveAttribute"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <canRemoveAttribute obj="root" attrname='"price"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="5" ignoreCase="false" id="canRemoveAttributeTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canRemoveChildFalse.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canRemoveChildFalse"> |
| <metadata> |
| <title>canRemoveChildFalse</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canRemoveChild checks if schema allows the child to be removed |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-NodeEditVAL-canRemoveChild"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="oldchild" type="Node"/> |
| <var name="nlist" type="NodeList"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"ISBN"' var="nlist"/> |
| <item obj="nlist" index="0" var="oldchild" interface="NodeList"/> |
| <documentElement obj="doc" var="root"/> |
| <canRemoveChild obj="root" oldChild="oldchild" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canRemoveChildFalse"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canRemoveChildTrue.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canRemoveChildTrue"> |
| <metadata> |
| <title>canRemoveChildTrue</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canRemoveChild checks if schema allows the child to be removed |
| should return VAL_TRUE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-NodeEditVAL-canRemoveChild"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="oldchild" type="Node"/> |
| <var name="nlist" type="NodeList"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"edition"' var="nlist"/> |
| <item obj="nlist" index="0" var="oldchild" interface="NodeList"/> |
| <documentElement obj="doc" var="root"/> |
| <canRemoveChild obj="root" oldChild="oldchild" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="5" ignoreCase="false" id="canRemoveChildTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canReplaceChildFalse.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canReplaceChildFalse"> |
| <metadata> |
| <title>canReplaceChildFalse</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canReplaceChild checks with schema to see if new child 'editor' can replace |
| old child title |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-NodeEditVAL-canReplaceChild"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="oldchild" type="Node"/> |
| <var name="nlist" type="NodeList"/> |
| <var name="newchild" type="Element"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"title"' var="nlist"/> |
| <item obj="nlist" index="0" var="oldchild" interface="NodeList"/> |
| <documentElement obj="doc" var="root"/> |
| <createElementNS obj="doc" namespaceURI="nullNS" qualifiedName='"editor"' var="newchild"/> |
| <canReplaceChild obj="root" newChild="newchild" oldChild="oldchild" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canReplaceChildFalse"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canReplaceChildTrue.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canReplaceChildTrue"> |
| <metadata> |
| <title>canReplaceChildTrue</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canReplaceChild checks with schema to see if new child 'editor' can replace |
| old child 'author' |
| should return VAL_TRUE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-NodeEditVAL-canReplaceChild"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="oldchild" type="Node"/> |
| <var name="nlist" type="NodeList"/> |
| <var name="newchild" type="Element"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" tagname='"author"' var="nlist"/> |
| <item obj="nlist" index="0" var="oldchild" interface="NodeList"/> |
| <documentElement obj="doc" var="root"/> |
| <createElementNS obj="doc" namespaceURI="nullNS" qualifiedName='"editor"' var="newchild"/> |
| <canReplaceChild obj="root" newChild="newchild" oldChild="oldchild" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="5" ignoreCase="false" id="canReplaceChildTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canReplaceDataFalse.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canReplaceDataFalse"> |
| <metadata> |
| <title>canReplaceDataFalse</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method checks if given characters can replace exitsting text |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-CharacterDataEditVAL-canReplaceData"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="valboolean" type="short"/> |
| <var name="chars" type="CharacterDataEditVAL"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elemList" tagname='"edition"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <firstChild interface="Node" obj="elem" var="chars"/> |
| <canReplaceData obj="chars" offset="0" count="5" arg='"2nd"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canReplaceDataFalse"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canReplaceDataTrue.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canReplaceDataTrue"> |
| <metadata> |
| <title>canReplaceDataTrue</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method checks if given characters can replace exitsting text |
| should return VAL_TRUE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-CharacterDataEditVAL-canReplaceData"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="valboolean" type="short"/> |
| <var name="chars" type="CharacterDataEditVAL"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elemList" tagname='"edition"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <firstChild interface="Node" obj="elem" var="chars"/> |
| <canReplaceData obj="chars" offset="0" count="6" arg='"First"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="5" ignoreCase="false" id="canReplaceDataTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canSetAttributeFalse.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canSetAttributeFalse"> |
| <metadata> |
| <title>canSetAttributeFalse</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canSetAttribute checks if a new attribute 'attr' can be set |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-ElementEditVAL-canSetAttribute"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <canSetAttribute obj="root" attrname='"attr"' attrval='"No"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canSetAttributeFalse"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canSetAttributeNS.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canSetAttributeNS"> |
| <metadata> |
| <title>canSetAttributeNS</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canSetAttributeNS checks if an attribute with given namespace and name can be set |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-canSetAttributeNS"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <canSetAttributeNS obj="root" namespaceURI="nullNS" qualifiedName='"inStock"' value ='"out"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canSetAttributeNS"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canSetAttributeNode.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canSetAttributeNode"> |
| <metadata> |
| <title>canSetAttributeNode</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canSteAttribute checks if a new attribute node 'attname' can be set |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-canSetAttributeNode"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <var name="attr" type="Attr"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <createAttribute obj="doc" var="attr" name='"attname"'/> |
| <canSetAttributeNode obj="root" attrNode="attr" var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canSetAttributeNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canSetAttributeTrue.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canSetAttributeTrue"> |
| <metadata> |
| <title>canSetAttributeTrue</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method canSetAttribute checks if value attribute 'inStock' can be set |
| should return VAL_TRUE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-ElementEditVAL-canSetAttribute"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <canSetAttribute obj="root" attrname='"inStock"' attrval='"No"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="5" ignoreCase="false" id="canSetAttributeTrue"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/canSetData.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="canSetData"> |
| <metadata> |
| <title>canSetData</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method checks if given characters can be set as the content of element 'edition' |
| should return VAL_FALSE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-CharacterDataEditVAL-canSetData"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="elem" type="Element"/> |
| <var name="valboolean" type="short"/> |
| <var name="chars" type="CharacterDataEditVAL"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName obj="doc" interface="Document" var="elemList" tagname='"edition"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <firstChild interface="Node" obj="elem" var="chars"/> |
| <canSetData obj="chars" arg='"USD60"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="canSetData"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/contentType.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="contentType"> |
| <metadata> |
| <title>contentType</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| get the content type of element, should return VAL_ELEMENTS_CONTENTTYPE |
| should return 4 |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-ElementEditVAL-contentType"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="content" type="short"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <contentType interface="ElementEditVAL" obj="root" var="content"/> |
| <assertEquals actual="content" expected="4" ignoreCase="false" id="contentType"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/defaultValue.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="defaultValue"> |
| <metadata> |
| <title>defaultValue</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method returns the default value of the element. |
| Should return null |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#NodeEditVAL-defaultValue"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="ElementEditVAL"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="value" type="DOMString"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName obj="doc" interface="Document" var="elemList" tagname='"edition"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <defaultValue interface="NodeEditVAL" obj="elem" var="value"/> |
| <assertEquals actual="value" expected='"First"' ignoreCase="false" id="defaultValue"/></test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/definedElements.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="definedElements"> |
| <metadata> |
| <title>definedElements</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method retrieves all element declarations defined by schema |
| should return a NameList of length 8 |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#DocumentEditVAL-getDefinedElements"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="DocumentEditVAL"/> |
| <var name="nameList" type="NameList"/> |
| <var name="nullNS" type="DOMString" isNull="true"/> |
| <var name="definedElementsLength" type="int"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getDefinedElements obj="doc" interface="DocumentEditVAL" namespaceURI="nullNS" var="nameList"/> |
| <assertNotNull actual="nameList" id="definedElementsNotNull"/> |
| <length var="definedElementsLength" obj="nameList" interface="NameList"/> |
| <assertEquals expected="8" actual="definedElementsLength" id="definedElements" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/enumeratedValues.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="enumeratedValues"> |
| <metadata> |
| <title>enumeratedValuess</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method enumeratedValues returns a DOMStringList of enumerated values for |
| the element. |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#NodeEditVAL-enumeratedValues"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="NodeEditVAL"/> |
| <var name="elemList" type="NodeList"/> |
| <var name="strlist" type="DOMStringList"/> |
| <var name="enumeratedValuesLength" type="int"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <getElementsByTagName interface="Document" obj="doc" var="elemList" tagname='"edition"'/> |
| <item interface="NodeList" obj="elemList" index="0" var="elem"/> |
| <enumeratedValues interface="NodeEditVAL" obj="elem" var="strlist"/> |
| <assertNotNull actual="strlist" id="enumeratedValuesNotNull"/> |
| <length var="enumeratedValuesLength" obj="strlist" interface="DOMStringList"/> |
| <assertEquals actual="enumeratedValuesLength" expected="5" id="enumeratedValues" ignoreCase="false"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/files/CVS/Entries |
|---|
| 0,0 → 1,3 |
| /book.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /book.xsd/1.1/Fri Apr 3 02:47:58 2009// |
| D |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/validation/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/files/CVS/Template |
|---|
| --- test/testcases/tests/level3/validation/files/book.xml (nonexistent) |
| +++ test/testcases/tests/level3/validation/files/book.xml (revision 4364) |
| @@ -0,0 +1,10 @@ |
| +<?xml version="1.0"?> |
| +<book inStock="Yes" price="64.28" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| + xsi:noNamespaceSchemaLocation="book.xsd"> |
| +<title>Compilers: Principles, Techniques, and Tools</title> |
| +<author>Alfred V.Aho, Ravi Sethi, Jeffrey D. Ullman</author> |
| +<ISBN>0-201-10088-6</ISBN> |
| +<edition>Second</edition> |
| +<publisher>Addison Wesley</publisher> |
| +</book> |
| + |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/files/book.xsd |
|---|
| 0,0 → 1,52 |
| <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> |
| <xsd:element name="book" type="bookType"/> |
| <xsd:complexType name="bookType"> |
| <xsd:sequence> |
| <xsd:element ref="title"/> |
| <xsd:choice> |
| <xsd:element ref="author"/> |
| <xsd:element ref="editor"/> |
| </xsd:choice> |
| <xsd:element ref="ISBN"/> |
| <xsd:element ref="edition" minOccurs ="0"/> |
| <xsd:element ref="publisher"/> |
| <xsd:element ref="year" minOccurs="0"/> |
| </xsd:sequence> |
| <xsd:attribute name="price" type="xsd:decimal"/> |
| <xsd:attribute name="inStock" use="required"> |
| <xsd:simpleType> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="Yes"/> |
| <xsd:enumeration value="No"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| </xsd:attribute> |
| </xsd:complexType> |
| <xsd:element name="title" type="xsd:string"/> |
| <xsd:element name="author" type="xsd:string"/> |
| <xsd:element name="ISBN" type="xsd:string"/> |
| <xsd:element name="edition" default="First"> |
| <xsd:simpleType> |
| <xsd:restriction base="xsd:string"> |
| <xsd:enumeration value="First"/> |
| <xsd:enumeration value="Second"/> |
| <xsd:enumeration value="Third"/> |
| <xsd:enumeration value="Fourth"/> |
| <xsd:enumeration value="Fifth"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| </xsd:element> |
| <xsd:element name="publisher" type="xsd:string"/> |
| <xsd:element name="editor" type ="xsd:string"/> |
| <xsd:element name="year"> |
| <xsd:simpleType> |
| <xsd:restriction base="xsd:string"> |
| <xsd:pattern value ="[0-9]{4}"/> |
| </xsd:restriction> |
| </xsd:simpleType> |
| </xsd:element> |
| </xsd:schema> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/getFeature01.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="getFeature01"> |
| <metadata> |
| <title>getFeature01</title> |
| <creator>Curt Arnold</creator> |
| <description>Call DOMImplementation.getFeature("Validation", "3.0"). |
| Not sure what should happen. Have requested clarification from WG.</description> |
| <date qualifier="created">2004-01-05</date> |
| <!-- DOMImplementation.getFeature --> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Core-20031107/core#DOMImplementation3-getFeature"/> |
| </metadata> |
| <hasFeature feature='"Core"' version='"3.0"'/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplVAL" type="DOMImplementation"/> |
| <implementation var="domImpl"/> |
| <getFeature var="domImplVAL" obj="domImpl" |
| feature='"Validation"' version='"3.0"' interface="DOMImplementation"/> |
| <!-- TODO: Request for clarification. The spec doesn't address case where |
| feature does not introduce new interface --> |
| <assertNull actual="domImplVAL" id="getFeatureReturnsNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/getFeature02.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="getFeature02"> |
| <metadata> |
| <title>getFeature02</title> |
| <creator>Curt Arnold</creator> |
| <description>Call DOMImplementation.getFeature("+vAlIdAtIoN", "3.0").</description> |
| <date qualifier="created">2004-01-05</date> |
| <!-- DOMImplementation.getFeature --> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Core-20031107/core#DOMImplementation3-getFeature"/> |
| </metadata> |
| <hasFeature feature='"Core"' version='"3.0"'/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="domImplVAL" type="DOMImplementation"/> |
| <implementation var="domImpl"/> |
| <getFeature var="domImplVAL" obj="domImpl" feature='"+vAlIdAtIoN"' |
| version='"3.0"' interface="DOMImplementation"/> |
| <assertNull actual="domImplVAL" id="domImplVALNull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/hasFeature01.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="hasFeature01"> |
| <metadata> |
| <title>hasFeature01</title> |
| <creator>Curt Arnold</creator> |
| <description>Implementations should return true for hasFeature("vAlIdAtIoN", "3.0").</description> |
| <date qualifier="created">2004-01-05</date> |
| <!-- DOMImplementation.hasFeature --> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Core-20031107/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasVAL" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature var="hasVAL" obj="domImpl" feature='"vAlIdAtIoN"' version='"3.0"'/> |
| <assertTrue actual="hasVAL" id="hasFeature_VAL3"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/hasFeature02.xml |
|---|
| 0,0 → 1,40 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="hasFeature02"> |
| <metadata> |
| <title>HasFeature02</title> |
| <creator>Curt Arnold</creator> |
| <description>Implementations should return true for hasFeature("vAlIdAtIoN", null).</description> |
| <date qualifier="created">2004-01-05</date> |
| <!-- DOMImplementation.hasFeature --> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Core-20031107/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasVAL" type="boolean"/> |
| <var name="version" type="DOMString" isNull="true"/> |
| <implementation var="domImpl"/> |
| <hasFeature var="hasVAL" obj="domImpl" feature='"vAlIdAtIoN"' version="version"/> |
| <assertTrue actual="hasVAL" id="hasFeature_VAL"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/hasFeature03.xml |
|---|
| 0,0 → 1,42 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="hasFeature03"> |
| <metadata> |
| <title>hasFeature03</title> |
| <creator>Curt Arnold</creator> |
| <description>Implementations should return true for hasFeature("cOrE", "2.0") and hasFeature("cOrE", null).</description> |
| <date qualifier="created">2004-01-05</date> |
| <!-- DOMImplementation.hasFeature --> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Core-20031107/core#ID-5CED94D7"/> |
| </metadata> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasCore" type="boolean"/> |
| <var name="nullVersion" type="DOMString" isNull="true"/> |
| <implementation var="domImpl"/> |
| <hasFeature var="hasCore" obj="domImpl" feature='"cOrE"' version='"2.0"'/> |
| <assertTrue actual="hasCore" id="hasFeature_Core2"/> |
| <hasFeature var="hasCore" obj="domImpl" feature='"cOrE"' version="nullVersion"/> |
| <assertTrue actual="hasCore" id="hasFeature_Core"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/hasFeature04.xml |
|---|
| 0,0 → 1,41 |
| <?xml version="1.0" standalone="no"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003-2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="hasFeature04"> |
| <metadata> |
| <title>hasFeature04</title> |
| <creator>Curt Arnold</creator> |
| <description>Implementations should return true for hasFeature("+vAlIdAtIoN", "3.0").</description> |
| <date qualifier="created">2003-12-09</date> |
| <!-- DOMImplementation.hasFeature --> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Core-20031107/core#ID-5CED94D7"/> |
| </metadata> |
| <!-- + on feature names requires L3 Core --> |
| <hasFeature feature='"Core"' version='"3.0"'/> |
| <var name="domImpl" type="DOMImplementation"/> |
| <var name="hasVAL" type="boolean"/> |
| <implementation var="domImpl"/> |
| <hasFeature var="hasVAL" obj="domImpl" feature='"+vAlIdAtIoN"' version='"3.0"'/> |
| <assertTrue actual="hasVAL" id="hasFeature_VAL3"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/isElementDefined.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="isElementDefined"> |
| <metadata> |
| <title>isElementDefined</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method checks if element with given name is defined or not |
| should return VAL_TRUE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-isElementDefined"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <isElementDefined obj="root" name='"editor"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="5" ignoreCase="false" id="isElementDefined"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/isElementDefinedNS.xml |
|---|
| 0,0 → 1,43 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="isElementDefinedNS"> |
| <metadata> |
| <title>isElementDefinedNS</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| This method checks if element with given namespace and name is defined or not |
| should return VAL_TRUE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-ElementEditVAL-isElementDefined"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="valboolean" type="short"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <isElementDefinedNS obj="root" namespaceURI='"http://dom3.validation.examples"' name='"editor"' var="valboolean"/> |
| <assertEquals actual="valboolean" expected="6" ignoreCase="false" id="isElementDefinedNS"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/metadata.xml |
|---|
| 0,0 → 1,19 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, Institut National de |
| Recherche en Informatique et en Automatique, Keio University). All |
| Rights Reserved. This program is distributed under the W3C's Software |
| Intellectual Property License. This program is distributed in the |
| hope that it will be useful, but WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| See W3C License http://www.w3.org/Consortium/Legal/ for more details. |
| --> |
| <!DOCTYPE metadata SYSTEM "dom3.dtd"> |
| <!-- This file contains additional metadata about DOM L3 Validation tests. |
| Allowing additional documentation without modifying the tests themselves. --> |
| <metadata xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3"> |
| </metadata> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/nodeValidity.xml |
|---|
| 0,0 → 1,39 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="nodeValidity"> |
| <metadata> |
| <title>nodeValidity</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| check node validity, should return VAL_TRUE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#NodeEditVAL-nodeValidity"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="elem" type="ElementEditVAL"/> |
| <var name="result" type="short"/> |
| <var name="checkLevel" type="short" value="4"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="elem"/> |
| <nodeValidity obj="elem" valType="checkLevel" var="result"/> |
| <assertEquals actual="result" expected="5" ignoreCase="false" id="nodevalidity"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/requiredAttributes.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="requiredAttributes"> |
| <metadata> |
| <title>requiredAttributes</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| The method requiredAttributes returns the NameList of required attributes for |
| the element. |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#ElementEditVAL-requiredAttributes"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="Document"/> |
| <var name="root" type="ElementEditVAL"/> |
| <var name="attrlist" type="NameList"/> |
| <var name="attname" type="DOMString"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <documentElement obj="doc" var="root"/> |
| <requiredAttributes interface="ElementEditVAL" obj="root" var="attrlist"/> |
| <assertNotNull actual="attrlist" id="requiredAttributesNotNull"/> |
| <getName interface="NameList" obj="attrlist" index="0" var="attname"/> |
| <assertEquals actual="attname" expected='"inStock"' ignoreCase="false" id="requiredAttributes"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/validation/validateDocument.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 Oracle |
| All Rights Reserved. This program is distributed under the W3C's |
| Software Intellectual Property License [1]. This program is distributed |
| in the hope that it will be useful, but WITHOUT ANY WARRANTY; without |
| even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd"> |
| <test xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-3" name="validateDocument"> |
| <metadata> |
| <title>validateDocument</title> |
| <creator>Kongyi Zhou</creator> |
| <description> |
| validate the document, should return VAL_TRUE |
| </description> |
| <contributor>Oracle Corp.</contributor> |
| <date qualifier="created">2003-03-01</date> |
| <subject resource="http://www.w3.org/TR/2003/CR-DOM-Level-3-Val-20030730/validation#VAL-Interfaces-DocumentEditVAL-validateDocument"/> |
| </metadata> |
| <implementationAttribute name="schemaValidating" value="true"/> |
| <var name="doc" type="DocumentEditVAL"/> |
| <var name="result" type="short"/> |
| <load var="doc" href="book" willBeModified="false"/> |
| <validateDocument obj="doc" var="result"/> |
| <assertEquals actual="result" expected="5" ignoreCase="false" id="validateDocument"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/.cvsignore |
|---|
| 0,0 → 1,3 |
| dom3.dtd |
| dom3.xsd |
| test-to-html.xsl |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Attribute_Nodes.xml |
|---|
| 0,0 → 1,118 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Attribute_Nodes"> |
| <metadata> |
| <title>Attribute_Nodes</title> |
| <creator>Bob Clary</creator> |
| <description> |
| S1.2.2 Attribute Nodes - |
| Create ANY_TYPE XPathResult matching //@*, |
| check that each matching Node is an Attribute Node, |
| that parentNodes of returned Attributes are null, |
| and that ownerElements are in fact Elements. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#Mapping"/> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResult-iterateNext"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""//@*"" /> |
| <var name="xpathType" type="short" value="ANY_TYPE" /> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="parent" type="Node"/> |
| <var name="owner" type="Node"/> |
| <var name="ownerType" type="int"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" /> |
| <!-- Test Body --> |
| <iterateNext var="outNode" obj="outresult"/> |
| <while> |
| <notNull obj="outNode"/> |
| <nodeType var="nodeType" obj="outNode" /> |
| <assertEquals id="S1.2.2-Attribute-Nodes-nodeType" |
| actual="nodeType" |
| expected="2" |
| ignoreCase="false"/> |
| <parentNode var="parent" obj="outNode" interface="Node"/> |
| <assertNull id="S1.2.2-Attribute-Nodes-parentNode" actual="parent"/> |
| <ownerElement var="owner" obj="outNode" interface="Attr"/> |
| <nodeType var="ownerType" obj="owner"/> |
| <assertEquals id="S1.2.2-Attribute-Nodes-owner-nodeType" |
| actual="ownerType" |
| expected="1" |
| ignoreCase="false"/> |
| <iterateNext var="outNode" obj="outresult"/> |
| </while> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Attribute_Nodes_xmlns.xml |
|---|
| 0,0 → 1,94 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Attribute_Nodes_xmlns"> |
| <metadata> |
| <title>Attribute_Nodes_xmlns</title> |
| <creator>Bob Clary</creator> |
| <description> |
| S1.2.2 Attribute Nodes - |
| Create ANY_TYPE XPathResult matching //@xmlns, |
| check that there are no matching Nodes by |
| checking for XPathResult.iterateNext == null |
| since namespace attributes are not retrievable. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#Mapping"/> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResult-iterateNext"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""//@xmlns""/> |
| <var name="xpathType" type="short" value="ANY_TYPE" /> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" /> |
| <!-- Test Body --> |
| <iterateNext var="outNode" obj="outresult"/> |
| <assertNull id="Attribute_Nodes_xmlnsxmlns" actual="outNode"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/CVS/Entries |
|---|
| 0,0 → 1,70 |
| D/files//// |
| /.cvsignore/1.1/Fri Apr 3 02:47:58 2009// |
| /Attribute_Nodes.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /Attribute_Nodes_xmlns.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /Comment_Nodes.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /Conformance_Expressions.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /Conformance_ID.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /Conformance_hasFeature_3.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /Conformance_hasFeature_empty.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /Conformance_hasFeature_null.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /Conformance_isSupported_3.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /Conformance_isSupported_empty.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /Conformance_isSupported_null.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /Element_Nodes.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /Processing_Instruction_Nodes.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /Text_Nodes.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluatorCast01.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_createExpression_INVALID_EXPRESSION_ERR.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_createExpression_NAMESPACE_ERR_01.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_createExpression_NAMESPACE_ERR_02.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_createExpression_NS.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_createExpression_no_NS.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_createNSResolver_all.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_createNSResolver_document.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_createNSResolver_documentElement.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_evaluate_INVALID_EXPRESSION_ERR.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_evaluate_NAMESPACE_ERR.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_evaluate_NOT_SUPPORTED_ERR.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_evaluate_TYPE_ERR.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_evaluate_WRONG_DOCUMENT_ERR.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_evaluate_document.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathEvaluator_evaluate_documentElement.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /XPathExpression_evaluate_NOT_SUPPORTED_ERR.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathExpression_evaluate_WRONG_DOCUMENT_ERR.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathExpression_evaluate_document.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathExpression_evaluate_documentElement.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathNSResolver_lookupNamespaceURI_nist_dmstc.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathNSResolver_lookupNamespaceURI_null.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathNSResolver_lookupNamespaceURI_prefix.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathNSResolver_lookupNamespaceURI_xml.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_TYPE_ERR.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_booleanValue_false.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_booleanValue_true.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_invalidIteratorState_ANY_TYPE.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathResult_invalidIteratorState_ANY_UNORDERED_NODE_TYPE.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathResult_invalidIteratorState_BOOLEAN_TYPE.xml/1.4/Fri Apr 3 02:47:58 2009// |
| /XPathResult_invalidIteratorState_FIRST_ORDERED_NODE_TYPE.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathResult_invalidIteratorState_NUMBER_TYPE.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathResult_invalidIteratorState_ORDERED_NODE_ITERATOR_TYPE.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathResult_invalidIteratorState_ORDERED_NODE_SNAPSHOT_TYPE.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathResult_invalidIteratorState_STRING_TYPE.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathResult_invalidIteratorState_UNORDERED_NODE_ITERATOR_TYPE.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathResult_invalidIteratorState_UNORDERED_NODE_SNAPSHOT_TYPE.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathResult_iterateNext_INVALID_STATE_ERR.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /XPathResult_iteratorNext_ORDERED_NODE_ITERATOR_TYPE.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_iteratorNext_UNORDERED_NODE_ITERATOR_TYPE.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_numberValue.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_resultType.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_singleNodeValue_ANY_UNORDERED_NODE_TYPE.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_singleNodeValue_FIRST_ORDERED_NODE_TYPE.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_snapshotItem_ORDERED_NODE_SNAPSHOT_TYPE_null.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_snapshotItem_ORDERED_NODE_SNAPSHOT_TYPE_order.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_snapshotItem_UNORDERED_NODE_SNAPSHOT_TYPE_count.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_snapshotItem_UNORDERED_NODE_SNAPSHOT_TYPE_null.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_snapshotLength_ORDERED_NODE_SNAPSHOT_TYPE.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_snapshotLength_UNORDERED_NODE_SNAPSHOT_TYPE.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /XPathResult_stringValue.xml/1.3/Fri Apr 3 02:47:58 2009// |
| /alltests.xml/1.6/Fri Apr 3 02:47:58 2009// |
| /dom3xpathents.ent/1.4/Fri Apr 3 02:47:58 2009// |
| /metadata.xml/1.2/Fri Apr 3 02:47:58 2009// |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/xpath |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/CVS/Template |
|---|
| --- test/testcases/tests/level3/xpath/Comment_Nodes.xml (nonexistent) |
| +++ test/testcases/tests/level3/xpath/Comment_Nodes.xml (revision 4364) |
| @@ -0,0 +1,104 @@ |
| +<?xml version="1.0" encoding="iso-8859-1"?> |
| +<?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| +<!-- |
| + Copyright (c) 2003 World Wide Web Consortium, |
| + |
| + (Massachusetts Institute of Technology, European Research Consortium for |
| + Informatics and Mathematics, Keio University). All Rights Reserved. This |
| + work is distributed under the W3C(r) Software License [1] in the hope that |
| + it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| + warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| + |
| + [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| +--> |
| + |
| +<!DOCTYPE test SYSTEM "dom3.dtd" [ |
| + <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| + %entities; |
| +]> |
| +<test xmlns="&level3;" name="Comment_Nodes"> |
| + <metadata> |
| + <title>Comment_Nodes</title> |
| + <creator>Bob Clary</creator> |
| + <description> |
| + S1.2.6 Comment Nodes - |
| + Create ANY_TYPE XPathResult matching //comment(), |
| + check that each matching Node is a Comment Node. |
| + </description> |
| + <date qualifier="created">2003-12-02</date> |
| + <subject resource="&spec;#Mapping"/> |
| + <subject resource="&spec;#XPathEvaluator"/> |
| + <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| + <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| + <subject resource="&spec;#XPathNSResolver"/> |
| + <subject resource="&spec;#XPathResult"/> |
| + <subject resource="&spec;#XPathResult-iterateNext"/> |
| + </metadata> |
| + |
| + <!-- Standard Variables --> |
| + |
| + <var name="ANY_TYPE" type="short" value="0"/> |
| + <var name="NUMBER_TYPE" type="short" value="1"/> |
| + <var name="STRING_TYPE" type="short" value="2"/> |
| + <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| + <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| + <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| + <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| + <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| + <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| + <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| + |
| + <var name="doc" type="Document" /> |
| + <var name="resolver" type="XPathNSResolver" /> |
| + <var name="evaluator" type="XPathEvaluator" /> |
| + <var name="contextNode" type="Node" /> |
| + <var name="inresult" type="XPathResult" isNull="true"/> |
| + <var name="outresult" type="XPathResult" isNull="true"/> |
| + |
| + <!-- Inputs --> |
| + |
| + <var name="expression" type="DOMString" value=""//comment()""/> |
| + <var name="xpathType" type="short" value="ANY_TYPE" /> |
| + |
| + <!-- Test Variables --> |
| + |
| + <var name="currNode" type="Node"/> |
| + <var name="nodeType" type="int"/> |
| + |
| + <!-- Load Test Document --> |
| + |
| + <load var="doc" href="staff" willBeModified="false"/> |
| + |
| + <!-- Get XPathResult --> |
| + |
| + <createXPathEvaluator var="evaluator" document="doc"/> |
| + <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| + |
| + <assign var="contextNode" value="doc"/> |
| + |
| + <evaluate obj="evaluator" |
| + var="outresult" |
| + expression="expression" |
| + contextNode="contextNode" |
| + resolver="resolver" |
| + type="xpathType" |
| + result="inresult" |
| + interface="XPathEvaluator" /> |
| + |
| + <!-- Test Body --> |
| + |
| + <iterateNext var="currNode" obj="outresult"/> |
| + <while> |
| + <notNull obj="currNode"/> |
| + |
| + <nodeType var="nodeType" obj="currNode" /> |
| + <assertEquals id="S1.2.6-Comment-Nodes-nodeType" |
| + actual="nodeType" |
| + expected="8" |
| + ignoreCase="false"/> |
| + |
| + <iterateNext var="currNode" obj="outresult"/> |
| + |
| + </while> |
| + |
| +</test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Conformance_Expressions.xml |
|---|
| 0,0 → 1,280 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Conformance_Expressions"> |
| <metadata> |
| <title>Conformance_Expressions</title> |
| <creator>Bob Clary</creator> |
| <description> |
| 1.3 Conformance - Iterate over a list of strings containing |
| valid XPath expressions, calling XPathEvaluator.createExpression |
| for each. If no expections are thrown and each result is non-null, |
| then the test passes. |
| </description> |
| <date qualifier="created">2003-11-18</date> |
| <subject resource="&spec;#Conformance"/> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-createExpression"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="doc" type="Document"/> |
| <var name="resolver" type="XPathNSResolver"/> |
| <var name="evaluator" type="XPathEvaluator"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString"/> |
| <!-- Test Variables --> |
| <var name="expressionList" type="List"/> |
| <var name="xpathexpression" type="XPathExpression"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createXPathEvaluator var='evaluator' document='doc'/> |
| <createNSResolver var="resolver" obj="evaluator" nodeResolver="doc"/> |
| <!-- test root absolute expression --> |
| <append collection="expressionList" item=""/""/> |
| <!-- test verbose axes and basic node tests --> |
| <append collection="expressionList" item=""child::comment()""/> |
| <append collection="expressionList" item=""child::text()""/> |
| <append collection="expressionList" item=""child::processing-instruction()""/> |
| <append collection="expressionList" item=""child::processing-instruction('name')""/> |
| <append collection="expressionList" item=""child::node()""/> |
| <append collection="expressionList" item=""child::*""/> |
| <append collection="expressionList" item=""child::nist:*""/> |
| <append collection="expressionList" item=""child::employee""/> |
| <append collection="expressionList" item=""descendant::comment()""/> |
| <append collection="expressionList" item=""descendant::text()""/> |
| <append collection="expressionList" item=""descendant::processing-instruction()""/> |
| <append collection="expressionList" item=""descendant::processing-instruction('name')""/> |
| <append collection="expressionList" item=""descendant::node()""/> |
| <append collection="expressionList" item=""descendant::*""/> |
| <append collection="expressionList" item=""descendant::nist:*""/> |
| <append collection="expressionList" item=""descendant::employee""/> |
| <append collection="expressionList" item=""parent::comment()""/> |
| <append collection="expressionList" item=""parent::text()""/> |
| <append collection="expressionList" item=""parent::processing-instruction()""/> |
| <append collection="expressionList" item=""parent::processing-instruction('name')""/> |
| <append collection="expressionList" item=""parent::node()""/> |
| <append collection="expressionList" item=""parent::*""/> |
| <append collection="expressionList" item=""parent::nist:*""/> |
| <append collection="expressionList" item=""parent::employee""/> |
| <append collection="expressionList" item=""ancestor::comment()""/> |
| <append collection="expressionList" item=""ancestor::text()""/> |
| <append collection="expressionList" item=""ancestor::processing-instruction()""/> |
| <append collection="expressionList" item=""ancestor::processing-instruction('name')""/> |
| <append collection="expressionList" item=""ancestor::node()""/> |
| <append collection="expressionList" item=""ancestor::*""/> |
| <append collection="expressionList" item=""ancestor::nist:*""/> |
| <append collection="expressionList" item=""ancestor::employee""/> |
| <append collection="expressionList" item=""following-sibling::comment()""/> |
| <append collection="expressionList" item=""following-sibling::text()""/> |
| <append collection="expressionList" item=""following-sibling::processing-instruction()""/> |
| <append collection="expressionList" item=""following-sibling::processing-instruction('name')""/> |
| <append collection="expressionList" item=""following-sibling::node()""/> |
| <append collection="expressionList" item=""following-sibling::*""/> |
| <append collection="expressionList" item=""following-sibling::nist:*""/> |
| <append collection="expressionList" item=""following-sibling::employee""/> |
| <append collection="expressionList" item=""preceding-sibling::comment()""/> |
| <append collection="expressionList" item=""preceding-sibling::text()""/> |
| <append collection="expressionList" item=""preceding-sibling::processing-instruction()""/> |
| <append collection="expressionList" item=""preceding-sibling::processing-instruction('name')""/> |
| <append collection="expressionList" item=""preceding-sibling::node()""/> |
| <append collection="expressionList" item=""preceding-sibling::*""/> |
| <append collection="expressionList" item=""preceding-sibling::nist:*""/> |
| <append collection="expressionList" item=""preceding-sibling::employee""/> |
| <append collection="expressionList" item=""following::comment()""/> |
| <append collection="expressionList" item=""following::text()""/> |
| <append collection="expressionList" item=""following::processing-instruction()""/> |
| <append collection="expressionList" item=""following::processing-instruction('name')""/> |
| <append collection="expressionList" item=""following::node()""/> |
| <append collection="expressionList" item=""following::*""/> |
| <append collection="expressionList" item=""following::nist:*""/> |
| <append collection="expressionList" item=""following::employee""/> |
| <append collection="expressionList" item=""preceding::comment()""/> |
| <append collection="expressionList" item=""preceding::text()""/> |
| <append collection="expressionList" item=""preceding::processing-instruction()""/> |
| <append collection="expressionList" item=""preceding::processing-instruction('name')""/> |
| <append collection="expressionList" item=""preceding::node()""/> |
| <append collection="expressionList" item=""preceding::*""/> |
| <append collection="expressionList" item=""preceding::nist:*""/> |
| <append collection="expressionList" item=""preceding::employee""/> |
| <append collection="expressionList" item=""attribute::comment()""/> |
| <append collection="expressionList" item=""attribute::text()""/> |
| <append collection="expressionList" item=""attribute::processing-instruction()""/> |
| <append collection="expressionList" item=""attribute::processing-instruction('name')""/> |
| <append collection="expressionList" item=""attribute::node()""/> |
| <append collection="expressionList" item=""attribute::*""/> |
| <append collection="expressionList" item=""attribute::nist:*""/> |
| <append collection="expressionList" item=""attribute::employee""/> |
| <append collection="expressionList" item=""namespace::comment()""/> |
| <append collection="expressionList" item=""namespace::text()""/> |
| <append collection="expressionList" item=""namespace::processing-instruction()""/> |
| <append collection="expressionList" item=""namespace::processing-instruction('name')""/> |
| <append collection="expressionList" item=""namespace::node()""/> |
| <append collection="expressionList" item=""namespace::*""/> |
| <append collection="expressionList" item=""namespace::nist:*""/> |
| <append collection="expressionList" item=""namespace::employee""/> |
| <append collection="expressionList" item=""self::comment()""/> |
| <append collection="expressionList" item=""self::text()""/> |
| <append collection="expressionList" item=""self::processing-instruction()""/> |
| <append collection="expressionList" item=""self::processing-instruction('name')""/> |
| <append collection="expressionList" item=""self::node()""/> |
| <append collection="expressionList" item=""self::*""/> |
| <append collection="expressionList" item=""self::nist:*""/> |
| <append collection="expressionList" item=""self::employee""/> |
| <append collection="expressionList" item=""descendant-or-self::comment()""/> |
| <append collection="expressionList" item=""descendant-or-self::text()""/> |
| <append collection="expressionList" item=""descendant-or-self::processing-instruction()""/> |
| <append collection="expressionList" item=""descendant-or-self::processing-instruction('name')""/> |
| <append collection="expressionList" item=""descendant-or-self::node()""/> |
| <append collection="expressionList" item=""descendant-or-self::*""/> |
| <append collection="expressionList" item=""descendant-or-self::nist:*""/> |
| <append collection="expressionList" item=""descendant-or-self::employee""/> |
| <append collection="expressionList" item=""ancestor-or-self::comment()""/> |
| <append collection="expressionList" item=""ancestor-or-self::text()""/> |
| <append collection="expressionList" item=""ancestor-or-self::processing-instruction()""/> |
| <append collection="expressionList" item=""ancestor-or-self::processing-instruction('name')""/> |
| <append collection="expressionList" item=""ancestor-or-self::node()""/> |
| <append collection="expressionList" item=""ancestor-or-self::*""/> |
| <append collection="expressionList" item=""ancestor-or-self::nist:*""/> |
| <append collection="expressionList" item=""ancestor-or-self::employee""/> |
| <!-- test common abbreviations --> |
| <append collection="expressionList" item=""comment()""/> |
| <append collection="expressionList" item=""text()""/> |
| <append collection="expressionList" item=""processing-instruction()""/> |
| <append collection="expressionList" item=""processing-instruction('name')""/> |
| <append collection="expressionList" item=""node()""/> |
| <append collection="expressionList" item=""*""/> |
| <append collection="expressionList" item=""nist:*""/> |
| <append collection="expressionList" item=""employee""/> |
| <append collection="expressionList" item="".//comment()""/> |
| <append collection="expressionList" item="".//text()""/> |
| <append collection="expressionList" item="".//processing-instruction()""/> |
| <append collection="expressionList" item="".//processing-instruction('name')""/> |
| <append collection="expressionList" item="".//node()""/> |
| <append collection="expressionList" item="".//*""/> |
| <append collection="expressionList" item="".//nist:*""/> |
| <append collection="expressionList" item="".//employee""/> |
| <append collection="expressionList" item=""../comment()""/> |
| <append collection="expressionList" item=""../text()""/> |
| <append collection="expressionList" item=""../processing-instruction()""/> |
| <append collection="expressionList" item=""../processing-instruction('name')""/> |
| <append collection="expressionList" item=""../node()""/> |
| <append collection="expressionList" item=""../*""/> |
| <append collection="expressionList" item=""../nist:*""/> |
| <append collection="expressionList" item=""../employee""/> |
| <append collection="expressionList" item=""@attributename""/> |
| <append collection="expressionList" item=""./comment()""/> |
| <append collection="expressionList" item=""./text()""/> |
| <append collection="expressionList" item=""./processing-instruction()""/> |
| <append collection="expressionList" item=""./processing-instruction('name')""/> |
| <append collection="expressionList" item=""./node()""/> |
| <append collection="expressionList" item=""./*""/> |
| <append collection="expressionList" item=""./nist:*""/> |
| <append collection="expressionList" item=""./employee""/> |
| <!-- test Union --> |
| <append collection="expressionList" item=""comment() | text() | processing-instruction() | node()""/> |
| <!-- test various predicates --> |
| <append collection="expressionList" item=""employee[address]""/> |
| <append collection="expressionList" item=""employee/address[@street]""/> |
| <append collection="expressionList" item=""employee[position='Computer Specialist']""/> |
| <append collection="expressionList" item=""employee[position!='Computer Specialist']""/> |
| <append collection="expressionList" item=""employee[gender='Male' or gender='Female']""/> |
| <append collection="expressionList" item=""employee[gender!='Male' and gender!='Female']""/> |
| <append collection="expressionList" item=""employee/address[@street='Yes']""/> |
| <append collection="expressionList" item=""employee/address[@street!='Yes']""/> |
| <append collection="expressionList" item=""employee[position()=1]""/> |
| <append collection="expressionList" item=""employee[1]""/> |
| <append collection="expressionList" item=""employee[position()=last()]""/> |
| <append collection="expressionList" item=""employee[last()]""/> |
| <append collection="expressionList" item=""employee[position()>1 and position<last()]""/> |
| <append collection="expressionList" item=""employee[position()>=1 and position<=last()]""/> |
| <append collection="expressionList" item=""employee[count(.)>0]""/> |
| <append collection="expressionList" item=""employee[position() mod 2=0]""/> |
| <append collection="expressionList" item=""employee[position() mod -2=0]""/> |
| <append collection="expressionList" item=""employee[position() div 2=0]""/> |
| <append collection="expressionList" item=""employee[position() div -2=-1]""/> |
| <append collection="expressionList" item=""employee[position() div 2 * 2=position()]""/> |
| <append collection="expressionList" item=""employee[3 > 2 > 1]""/> |
| <append collection="expressionList" item=""id('CANADA')""/> |
| <append collection="expressionList" item=""*[local-name()='employee']""/> |
| <append collection="expressionList" item=""*[local-name(.)='employee']""/> |
| <append collection="expressionList" item=""*[local-name(employee)='employee']""/> |
| <append collection="expressionList" item=""*[local-name()='employee']""/> |
| <append collection="expressionList" item=""*[namespace-uri()='http://www.nist.gov']""/> |
| <append collection="expressionList" item=""*[name()='nist:employee']""/> |
| <append collection="expressionList" item=""*[string()]""/> |
| <append collection="expressionList" item=""*[string(10 div foo)='NaN']""/> |
| <append collection="expressionList" item=""*[concat('a', 'b', 'c')]""/> |
| <append collection="expressionList" item=""*[starts-with('employee', 'emp')]""/> |
| <append collection="expressionList" item=""*[contains('employee', 'emp')]""/> |
| <append collection="expressionList" item=""*[substring-before('employeeId', 'Id')]""/> |
| <append collection="expressionList" item=""*[substring-after('employeeId', 'employee')]""/> |
| <append collection="expressionList" item=""*[substring('employeeId', 4)]""/> |
| <append collection="expressionList" item=""*[substring('employeeId', 4, 5)]""/> |
| <append collection="expressionList" item=""*[string-length()=2]""/> |
| <append collection="expressionList" item=""*[string-length(.)=string-length(normalize-space(.))]""/> |
| <append collection="expressionList" item=""*[translate('bar', 'abc', 'ABC')='BAr']""/> |
| <append collection="expressionList" item=""*[boolean(.)]""/> |
| <append collection="expressionList" item=""*[not(boolean(.))]""/> |
| <append collection="expressionList" item=""*[true()]""/> |
| <append collection="expressionList" item=""*[false()]""/> |
| <append collection="expressionList" item=""*[lang('en')]""/> |
| <append collection="expressionList" item=""*[number()]""/> |
| <append collection="expressionList" item=""*[number('4')]""/> |
| <append collection="expressionList" item=""*[floor(.)]>0""/> |
| <append collection="expressionList" item=""*[ceiling(.)]<1""/> |
| <append collection="expressionList" item=""*[round(number(.))=0]<1""/> |
| <for-each collection="expressionList" member="expression"> |
| <createExpression var="xpathexpression" |
| obj="evaluator" |
| resolver="resolver" |
| expression="expression"/> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Conformance_ID.xml |
|---|
| 0,0 → 1,98 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Conformance_ID"> |
| <metadata> |
| <title>Conformance_ID</title> |
| <creator>Bob Clary</creator> |
| <description> |
| 1.3 Conformance - Check that the element returned by XPath id() function |
| returns the same element as Document.getElementById |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#Conformance"/> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathResult-iterateNext"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document"/> |
| <var name="resolver" type="XPathNSResolver"/> |
| <var name="evaluator" type="XPathEvaluator"/> |
| <var name="contextNode" type="Node"/> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""id('child1')""/> |
| <var name="xpathType" type="short" value="ANY_TYPE"/> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <var name="child1Element" type="Node"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="internaldtd" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" /> |
| <!-- Test Body --> |
| <iterateNext var="outNode" obj="outresult"/> |
| <getElementById var="child1Element" |
| obj="doc" |
| elementId=""child1""/> |
| <assertSame id="S1.3-Conformance-ID" |
| actual="outNode" |
| expected="child1Element"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Conformance_hasFeature_3.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Conformance_hasFeature_3"> |
| <metadata> |
| <title>Conformance_hasFeature_3</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| 1.3 Conformance - Test if |
| Document.implementation.hasFeature('XPath', "3.0") returns true |
| </description> |
| <date qualifier="created">2003-11-29</date> |
| <subject resource="&spec;#Conformance"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <var name="impl" type='DOMImplementation'/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="impl"/> |
| <hasFeature obj="impl" |
| feature=""xpATH"" |
| version=""3.0"" |
| var="state"/> |
| <assertTrue actual="state" id="hasFeature-XPath-3.0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Conformance_hasFeature_empty.xml |
|---|
| 0,0 → 1,47 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Conformance_hasFeature_empty"> |
| <metadata> |
| <title>Conformance_hasFeature_empty</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| 1.3 Conformance - Test if |
| Document.implementation.hasFeature('XPath', "") returns true |
| </description> |
| <date qualifier="created">2003-11-29</date> |
| <subject resource="&spec;#Interfaces"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <var name="impl" type='DOMImplementation'/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="impl"/> |
| <hasFeature obj="impl" |
| feature=""xpATH"" |
| version="""" |
| var="state"/> |
| <assertTrue actual="state" id="hasFeature-XPath-empty"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Conformance_hasFeature_null.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Conformance_hasFeature_null"> |
| <metadata> |
| <title>Conformance_hasFeature_null</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| 1.3 Conformance - Test if |
| Document.implementation.hasFeature('XPath', null) returns true |
| </description> |
| <date qualifier="created">2003-11-29</date> |
| <subject resource="&spec;#Conformance"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <var name="impl" type='DOMImplementation'/> |
| <var name="nullValue" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <implementation obj="doc" var="impl"/> |
| <hasFeature obj="impl" |
| feature=""xpATH"" |
| version="nullValue" |
| var="state"/> |
| <assertTrue actual="state" id="hasFeature-XPath-null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Conformance_isSupported_3.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Conformance_isSupported_3"> |
| <metadata> |
| <title>Conformance_isSupported_3</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| 1.3 Conformance - The "feature" parameter in the |
| "Node.isSupported(feature,version)" |
| method is the name of the feature and the version is the version |
| number of the feature to test. XPath is the legal value for the |
| XPath module. The method should return "true". |
| Retrieve the DOM document on which the |
| "isSupported(feature,version)" method is invoked with "feature" |
| equal to "XPath" and version to "3.0". The method should return a |
| boolean "true". |
| </description> |
| <date qualifier="created">2002-04-24</date> |
| <date qualifier="modified">2003-11-29</date> |
| <subject resource="&spec;#Conformance"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <isSupported obj="doc" feature=""xpATH"" |
| version=""3.0"" var="state"/> |
| <assertTrue actual="state" id="isSupported-XPath-3.0"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Conformance_isSupported_empty.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Conformance_isSupported_empty"> |
| <metadata> |
| <title>Conformance_isSupported_empty</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| 1.3 Conformance - The "feature" parameter in the |
| "Node.isSupported(feature,version)" |
| method is the name of the feature and the version is the version |
| number of the feature to test. XPath is the legal value for the |
| XPath module. The method should return "true". |
| Retrieve the DOM document on which the |
| "isSupported(feature,version)" method is invoked with "feature" |
| equal to "XPath" and version to the empty string "". The method |
| should return a boolean "true" if the implementation claims support |
| for some version for XPath. |
| </description> |
| <date qualifier="created">2002-04-24</date> |
| <date qualifier="modified">2003-11-29</date> |
| <subject resource="&spec;#Conformance"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <isSupported obj="doc" feature=""xpATH"" |
| version="""" var="state"/> |
| <assertTrue actual="state" id="isSupported-XPath-empty"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Conformance_isSupported_null.xml |
|---|
| 0,0 → 1,45 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Conformance_isSupported_null"> |
| <metadata> |
| <title>Conformance_isSupported_null</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| 1.3 Conformance - Test if |
| Document.isSupported('XPath', null) returns true |
| </description> |
| <date qualifier="created">2003-11-29</date> |
| <subject resource="&spec;#Conformance"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="state" type="boolean"/> |
| <var name="nullValue" type="DOMString" isNull="true"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <isSupported obj="doc" |
| feature=""xpATH"" |
| version="nullValue" |
| var="state"/> |
| <assertTrue actual="state" id="isSupported-XPath-null"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Element_Nodes.xml |
|---|
| 0,0 → 1,104 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Element_Nodes"> |
| <metadata> |
| <title>Element_Nodes</title> |
| <creator>Bob Clary</creator> |
| <description> |
| 1.2.1- Element Nodes - Evaluate /staff/employee, |
| check that each matching Node in the result |
| is an Element. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#Mapping"/> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-iterateNext"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document"/> |
| <var name="resolver" type="XPathNSResolver"/> |
| <var name="evaluator" type="XPathEvaluator"/> |
| <var name="contextNode" type="Node"/> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="ANY_TYPE"/> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" /> |
| <!-- Test Body --> |
| <iterateNext var="outNode" obj="outresult"/> |
| <while> |
| <notNull obj="outNode"/> |
| <nodeType var="nodeType" obj="outNode" /> |
| <assertEquals id="S1.2.1-Element-Nodes-nodeType" |
| actual="nodeType" |
| expected="1" |
| ignoreCase="false"/> |
| <iterateNext var="outNode" obj="outresult"/> |
| </while> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Processing_Instruction_Nodes.xml |
|---|
| 0,0 → 1,105 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Processing_Instruction_Nodes"> |
| <metadata> |
| <title>Processing_Instruction_Nodes</title> |
| <creator>Bob Clary</creator> |
| <description> |
| S1.2.7 Processing Instruction Nodes - |
| Create ANY_TYPE XPathResult matching //processing-instruction(), |
| check that each matching Node is a Processing Instruction Node. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#Mapping"/> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResult-iterateNext"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" |
| value=""//processing-instruction()""/> |
| <var name="xpathType" type="short" value="ANY_TYPE" /> |
| <!-- Test Variables --> |
| <var name="currNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" /> |
| <!-- Test Body --> |
| <iterateNext var="currNode" obj="outresult"/> |
| <while> |
| <notNull obj="currNode"/> |
| <nodeType var="nodeType" obj="currNode" /> |
| <assertEquals id="S1.2.7-Processing-Instruction-Nodes-nodetype" |
| actual="nodeType" |
| expected="7" |
| ignoreCase="false"/> |
| <iterateNext var="currNode" obj="outresult"/> |
| </while> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/Text_Nodes.xml |
|---|
| 0,0 → 1,150 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="Text_Nodes"> |
| <metadata> |
| <title>Text_Nodes</title> |
| <creator>Bob Clary</creator> |
| <description> |
| 1.2.4 Text Nodes - |
| Create ANY_TYPE XPathResult matching //text(), |
| check that each matching Node is a Text Node, and |
| that no pair of nodes in the result are siblings. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#Mapping"/> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResult-iterateNext"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""//text()"" /> |
| <var name="xpathType" type="short" value="ANY_TYPE" /> |
| <!-- Test Variables --> |
| <var name="currNode" type="Node"/> |
| <var name="nextNode" type="Node"/> |
| <var name="currNodeNextSibling" type="Node"/> |
| <var name="nextNodePrevSibling" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="isTextNode" type="DOMString" /> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc" /> |
| <createNSResolver var="resolver" obj="evaluator" nodeResolver="doc" /> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" /> |
| <!-- Test Body --> |
| <iterateNext var="currNode" obj="outresult" /> |
| <while> <notNull obj="currNode"/> |
| <nodeType var="nodeType" obj="currNode" /> |
| <assign var="isTextNode" value=""true""/> |
| <if> |
| <and> |
| <notEquals actual="nodeType" expected="3"/> |
| <notEquals actual="nodeType" expected="4"/> |
| </and> |
| <assign var="isTextNode" value=""false""/> |
| </if> |
| <assertEquals id="S1.2.4-Text-Nodes-nodeType" |
| actual="isTextNode" |
| expected=""true"" |
| ignoreCase="true"/> |
| <iterateNext var="nextNode" obj="outresult"/> |
| <if> |
| <notNull obj="nextNode"/> |
| <nextSibling var="currNodeNextSibling" |
| obj="currNode" interface="Node"/> |
| <if> |
| <same actual="currNodeNextSibling" expected="nextNode"/> |
| <comment>dummy statement</comment> |
| <else> |
| <assertTrue id="S1.2.4-Text-Nodes-Adjacent-Next" |
| actual="false" |
| /> |
| </else> |
| </if> |
| <previousSibling var="nextNodePrevSibling" |
| obj="nextNode" interface="Node"/> |
| <if> |
| <same actual="currNode" expected="nextNodePrevSibling"/> |
| <comment>dummy statement</comment> |
| <else> |
| <assertTrue id="S1.2.4-Text-Nodes-Adjacent-Prev" |
| actual="false" |
| /> |
| </else> |
| </if> |
| </if> |
| <assign var="currNode" value="nextNode"/> |
| </while> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluatorCast01.xml |
|---|
| 0,0 → 1,36 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluatorCast01"> |
| <metadata> |
| <title>XPathEvaluatorCast01</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| A document is created using implementation.createDocument and |
| cast to a XPathEvaluator interface. |
| </description> |
| <date qualifier="created">2002-04-24</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| </metadata> |
| &vars; |
| &findXPathEvaluator; |
| <assertNotNull actual="xpEvaluator" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_createExpression_INVALID_EXPRESSION_ERR.xml |
|---|
| 0,0 → 1,50 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_createExpression_INVALID_EXPRESSION_ERR"> |
| <metadata> |
| <title>XPathEvaluator_createExpression_INVALID_EXPRESSION_ERR</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| The XPathEvaluator can create a "XPathExpression" using the method |
| "createExpression(expression, resolver)". |
| Retrieve the DOM document on which the |
| 'createExpression("12a", null)' method is |
| invoked with the document element. The method should fail to create |
| pre-compiled expression and throws |
| XPathException.INVALID_EXPRESSION_ERR |
| since "12a" is not an XPath expression. |
| </description> |
| <date qualifier="created">2002-04-26</date> |
| <subject resource="&spec;#XPathEvaluator-createExpression"/> |
| </metadata> |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| &vars; |
| <var name="exp" type="XPathExpression"/> |
| &findXPathEvaluator; |
| <assertXPathException id="throw_INVALID_EXPRESSION_ERR"> |
| <INVALID_EXPRESSION_ERR> |
| <createExpression obj='xpEvaluator' var='exp' |
| expression='"12a"' resolver='nullNSResolver' /> |
| </INVALID_EXPRESSION_ERR> |
| </assertXPathException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_createExpression_NAMESPACE_ERR_01.xml |
|---|
| 0,0 → 1,49 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_createExpression_NAMESPACE_ERR_01"> |
| <metadata> |
| <title>XPathEvaluator_createExpression_NAMESPACE_ERR_01</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| The XPathEvaluator can create a "XPathExpression" using the method |
| "createExpression(expression, resolver)". |
| Retrieve the DOM document on which the |
| 'createExpression("/jfouffa:employee", null)' method is |
| invoked with the document element. The method should fail to create |
| pre-compiled expression and throws DOMException.NAMESPACE_ERR |
| since the prefix jfouffa is not mapped. |
| </description> |
| <date qualifier="created">2002-04-26</date> |
| <subject resource="&spec;#XPathEvaluator-createExpression"/> |
| </metadata> |
| &vars; |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="exp" type="XPathExpression"/> |
| &findXPathEvaluator; |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createExpression obj='xpEvaluator' var='exp' |
| expression='"/jfouffa:employee"' resolver='nullNSResolver' /> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_createExpression_NAMESPACE_ERR_02.xml |
|---|
| 0,0 → 1,55 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_createExpression_NAMESPACE_ERR_02"> |
| <metadata> |
| <title>XPathEvaluator_createExpression_NAMESPACE_ERR_02</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| The XPathEvaluator can create a "XPathExpression" using the method |
| "createExpression(expression, resolver)". |
| Retrieve the DOM document on which the |
| 'createExpression("/staff/jfouffa:employee", resolver)' method is |
| invoked with the document element. The method should fail to create |
| pre-compiled expression and throws DOMException.NAMESPACE_ERR |
| since the prefix jfouffa is not mapped. |
| </description> |
| <date qualifier="created">2002-04-26</date> |
| <subject resource="&spec;#XPathEvaluator-createExpression"/> |
| </metadata> |
| &vars; |
| <var name="exp" type="XPathExpression"/> |
| <var name="root" type='Element'/> |
| <var name="resolver" type="XPathNSResolver"/> |
| &findXPathEvaluator; |
| <documentElement obj='doc' var='root'/> |
| <createNSResolver obj="xpEvaluator" nodeResolver="root" |
| var="resolver"/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <createExpression obj='xpEvaluator' var='exp' |
| expression='"/staff/jfouffa:employee"' resolver='resolver' /> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_createExpression_NS.xml |
|---|
| 0,0 → 1,53 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_createExpression_NS"> |
| <metadata> |
| <title>XPathEvaluator_createExpression_NS</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| The XPathEvaluator can create a "XPathExpression" using the method |
| "createExpression(expression, resolver)". |
| Retrieve the DOM document on which the |
| 'createExpression("/staff/nist:employee", resolver)' method is |
| invoked with the document element. The method should return a |
| pre-compiled expression. |
| </description> |
| <date qualifier="created">2002-04-26</date> |
| <subject resource="&spec;#XPathEvaluator-createExpression"/> |
| </metadata> |
| &vars; |
| <var name="exp" type="XPathExpression"/> |
| <var name="root" type='Element'/> |
| <var name="resolver" type="XPathNSResolver"/> |
| &findXPathEvaluator; |
| <documentElement obj='doc' var='root'/> |
| <createNSResolver obj="xpEvaluator" nodeResolver="root" |
| var="resolver"/> |
| <createExpression obj='xpEvaluator' var='exp' |
| expression='"/staff/nist:employee"' resolver='resolver' /> |
| <assertNotNull actual="exp" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_createExpression_no_NS.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_createExpression_no_NS"> |
| <metadata> |
| <title>XPathEvaluator_createExpression_no_NS</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| The XPathEvaluator can create a "XPathExpression" using the method |
| "createExpression(expression, resolver)". |
| Retrieve the DOM document on which the |
| "createExpression("/", null)" method is invoked with the document |
| element. The method should return a pre-compiled expression. |
| </description> |
| <date qualifier="created">2002-04-26</date> |
| <subject resource="&spec;#XPathEvaluator-createExpression"/> |
| </metadata> |
| &vars; |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="exp" type="XPathExpression"/> |
| &findXPathEvaluator; |
| <createExpression obj='xpEvaluator' var='exp' |
| expression='"/"' resolver='nullNSResolver' /> |
| <assertNotNull actual="exp" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_createNSResolver_all.xml |
|---|
| 0,0 → 1,110 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_createNSResolver_all"> |
| <metadata> |
| <title>XPathEvaluator_createNSResolver_all</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Iterate over all nodes in the test document, creating |
| XPathNSResolvers checking that none return a null object. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="staff" type="Element"/> |
| <var name="staffchildren" type="NodeList"/> |
| <var name="staffchild" type="Node"/> |
| <var name="staffgrandchildren" type="NodeList"/> |
| <var name="staffgrandchild" type="Node"/> |
| <var name="staffgreatgrandchildren" type="NodeList"/> |
| <var name="staffgreatgrandchild" type="Node"/> |
| <var name="resolver" type="XPathNSResolver"/> |
| <var name="evaluator" type="XPathEvaluator"/> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <createXPathEvaluator var='evaluator' |
| document='doc'/> |
| <createNSResolver var="resolver" |
| obj="evaluator" |
| nodeResolver="doc"/> |
| <assertNotNull id="documentnotnull" |
| actual="resolver"/> |
| <documentElement var="staff" |
| obj="doc"/> |
| <createNSResolver var="resolver" |
| obj="evaluator" |
| nodeResolver="staff"/> |
| <assertNotNull id="documentElementnotnull" |
| actual="resolver"/> |
| <childNodes var="staffchildren" |
| obj="staff"/> |
| <for-each member="staffchild" |
| collection="staffchildren"> |
| <createNSResolver var="resolver" |
| obj="evaluator" |
| nodeResolver="staffchild"/> |
| <assertNotNull id="staffchildnotnull" |
| actual="resolver"/> |
| <childNodes var="staffgrandchildren" |
| obj="staffchild"/> |
| <for-each member="staffgrandchild" |
| collection="staffgrandchildren"> |
| <createNSResolver var="resolver" |
| obj="evaluator" |
| nodeResolver="staffgrandchild"/> |
| <assertNotNull id="staffgrandchildnotnull" |
| actual="resolver"/> |
| <childNodes var="staffgreatgrandchildren" |
| obj="staffgrandchild"/> |
| <for-each member="staffgreatgrandchild" |
| collection="staffgreatgrandchildren"> |
| <createNSResolver var="resolver" |
| obj="evaluator" |
| nodeResolver="staffgreatgrandchild"/> |
| <assertNotNull id="staffgreatgrandchildnotnull" |
| actual="resolver"/> |
| </for-each> |
| </for-each> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_createNSResolver_document.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_createNSResolver_document"> |
| <metadata> |
| <title>XPathEvaluator_createNSResolver_document</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| The XPathEvaluator can create "XPathNSResolver" using the method |
| "createNSResolver(nodeResolver)". |
| Retrieve the DOM document on which the |
| "createNSResolver(nodeResolver)" method is invoked with the document |
| itself. The method should return a resolver. |
| </description> |
| <date qualifier="created">2002-04-26</date> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| &vars; |
| <var name="resolver" type="XPathNSResolver"/> |
| &findXPathEvaluator; |
| <createNSResolver obj="xpEvaluator" nodeResolver="doc" var="resolver"/> |
| <assertNotNull actual="resolver" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_createNSResolver_documentElement.xml |
|---|
| 0,0 → 1,48 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_createNSResolver_documentElement"> |
| <metadata> |
| <title>XPathEvaluator_createNSResolver_documentElement</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| The XPathEvaluator can create "XPathNSResolver" using the method |
| "createNSResolver(nodeResolver)". |
| Retrieve the DOM document on which the |
| "createNSResolver(nodeResolver)" method is invoked with the document |
| element. The method should return a resolver. |
| </description> |
| <date qualifier="created">2002-04-26</date> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| &vars; |
| <var name="resolver" type="XPathNSResolver"/> |
| <var name="root" type='Element'/> |
| &findXPathEvaluator; |
| <documentElement obj='doc' var='root'/> |
| <createNSResolver obj="xpEvaluator" nodeResolver="root" |
| var="resolver"/> |
| <assertNotNull actual="resolver" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_evaluate_INVALID_EXPRESSION_ERR.xml |
|---|
| 0,0 → 1,56 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_evaluate_INVALID_EXPRESSION_ERR"> |
| <metadata> |
| <title>XPathEvaluator_evaluate_INVALID_EXPRESSION_ERR</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| Test if XPathEvaluator.evaluate properly throws INVALID_EXPRESSION_ERROR |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| </metadata> |
| &vars; |
| <var name="root" type='Element'/> |
| <var name="result" type="XPathResult"/> |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| &findXPathEvaluator; |
| <documentElement obj='doc' var='root'/> |
| <assertXPathException id="throw_INVALID_EXPRESSION_ERR"> |
| <INVALID_EXPRESSION_ERR> |
| <evaluate interface="XPathEvaluator" |
| obj='xpEvaluator' |
| var='result' |
| expression='"12a"' |
| contextNode='root' |
| resolver='nullNSResolver' |
| type='0' |
| result='nullResult'/> |
| </INVALID_EXPRESSION_ERR> |
| </assertXPathException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_evaluate_NAMESPACE_ERR.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_evaluate_NAMESPACE_ERR"> |
| <metadata> |
| <title>XPathEvaluator_evaluate_NAMESPACE_ERR</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| Test if XPathEvaluator.evaluate properly throws NAMESPACE_ERROR |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| </metadata> |
| &vars; |
| <var name="root" type='Element'/> |
| <var name="result" type="XPathResult"/> |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| &findXPathEvaluator; |
| <documentElement obj='doc' |
| var='root'/> |
| <assertDOMException id="throw_NAMESPACE_ERR"> |
| <NAMESPACE_ERR> |
| <evaluate interface="XPathEvaluator" |
| obj='xpEvaluator' |
| var='result' |
| expression='"//foo:bar"' |
| contextNode='root' |
| resolver='nullNSResolver' |
| type='0' |
| result='nullResult'/> |
| </NAMESPACE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_evaluate_NOT_SUPPORTED_ERR.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_evaluate_NOT_SUPPORTED_ERR"> |
| <metadata> |
| <title>XPathEvaluator_evaluate_NOT_SUPPORTED_ERR</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| Test if XPathEvaluator.evaluate properly throws NOT_SUPPORTED_ERROR |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| </metadata> |
| <var name='doc' type='Document'/> |
| <var name='xpEvaluator' type='XPathEvaluator'/> |
| <var name="result" type="XPathResult"/> |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| <var name="contextNode" type="Node"/> |
| <load var='doc' href='staffNS' willBeModified='false'/> |
| <createXPathEvaluator var='xpEvaluator' document='doc'/> |
| <createEntityReference var="contextNode" obj="doc" name=""entityname""/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <evaluate interface="XPathEvaluator" |
| obj='xpEvaluator' |
| var='result' |
| expression='"//foo:bar"' |
| contextNode='contextNode' |
| resolver='nullNSResolver' |
| type='0' |
| result='nullResult'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_evaluate_TYPE_ERR.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_evaluate_TYPE_ERR"> |
| <metadata> |
| <title>XPathEvaluator_evaluate_TYPE_ERR</title> |
| <creator>Curt Arnold</creator> |
| <description> |
| Evaluate "string(/)" and request that the result be a FIRST_ORDERED_NODE_TYPE, should |
| result in a TYPE_ERR. |
| </description> |
| <date qualifier="created">2004-01-10</date> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="http://www.w3.org/Bugs/Public/show_bug.cgi?id=508"/> |
| </metadata> |
| &vars; |
| <var name="result" type="XPathResult"/> |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| &findXPathEvaluator; |
| <assertXPathException id="throw_TYPE_ERR"> |
| <TYPE_ERR> |
| <evaluate interface="XPathEvaluator" obj='xpEvaluator' var='result' |
| expression='"string(/)"' contextNode='doc' resolver='nullNSResolver' type='9' result='nullResult'/> |
| </TYPE_ERR> |
| </assertXPathException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_evaluate_WRONG_DOCUMENT_ERR.xml |
|---|
| 0,0 → 1,60 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_evaluate_WRONG_DOCUMENT_ERR"> |
| <metadata> |
| <title>XPathEvaluator_evaluate_WRONG_DOCUMENT_ERR</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| Test if XPathEvaluator.evaluate properly throws WRONG_DOCUMENT_ERROR |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| </metadata> |
| <var name='doc1' type='Document'/> |
| <var name='doc2' type='Document'/> |
| <var name='xpEvaluator' type='XPathEvaluator'/> |
| <var name="root" type='Element'/> |
| <var name="result" type="XPathResult"/> |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| <load var='doc1' href='staffNS' willBeModified='false'/> |
| <load var='doc2' href='staff' willBeModified='false'/> |
| <createXPathEvaluator var='xpEvaluator' document='doc1'/> |
| <documentElement obj='doc2' var='root'/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <evaluate interface="XPathEvaluator" |
| obj='xpEvaluator' |
| var='result' |
| expression='"//foo:bar"' |
| contextNode='root' |
| resolver='nullNSResolver' |
| type='0' |
| result='nullResult'/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_evaluate_document.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_evaluate_document"> |
| <metadata> |
| <title>XPathEvaluator_evaluate_document</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| Retrieve the XPathEvaluator on which the |
| "evaluate("/", document, null, 0, null)" method is invoked with the document |
| element. The method should return an XPathResult. |
| </description> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| </metadata> |
| &vars; |
| <var name="root" type='Element'/> |
| <var name="result" type="XPathResult"/> |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| &findXPathEvaluator; |
| <assign value='doc' var='root'/> |
| <evaluate interface="XPathEvaluator" obj='xpEvaluator' var='result' |
| expression='"/"' contextNode='root' resolver='nullNSResolver' type='0' result='nullResult'/> |
| <assertNotNull actual="result" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathEvaluator_evaluate_documentElement.xml |
|---|
| 0,0 → 1,46 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathEvaluator_evaluate_documentElement"> |
| <metadata> |
| <title>XPathEvaluator_evaluate_documentElement</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| Retrieve the XPathEvaluator on which the |
| "evaluate("/", documentElement, null, 0, null)" method is invoked with the document |
| element. The method should return an XPathResult. |
| </description> |
| <date qualifier="created">2002-04-28</date> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| </metadata> |
| &vars; |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="root" type='Element'/> |
| <var name="result" type="XPathResult"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| &findXPathEvaluator; |
| <documentElement obj='doc' var='root'/> |
| <evaluate interface="XPathEvaluator" obj='xpEvaluator' var='result' |
| expression='"/"' contextNode='root' resolver='nullNSResolver' type='0' result='nullResult'/> |
| <assertNotNull actual="result" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathExpression_evaluate_NOT_SUPPORTED_ERR.xml |
|---|
| 0,0 → 1,64 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathExpression_evaluate_NOT_SUPPORTED_ERR"> |
| <metadata> |
| <title>XPathEvaluator_expression_NOT_SUPPORTED_ERR</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| Test if XPathExpression.evaluate properly throws NOT_SUPPORTED_ERROR |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathExpression-evaluate"/> |
| </metadata> |
| <var name='doc' type='Document'/> |
| <var name='xpEvaluator' type='XPathEvaluator'/> |
| <var name="result" type="XPathResult"/> |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| <var name="contextNode" type="Node"/> |
| <var name="xpathExpression" type="XPathExpression"/> |
| <load var='doc' href='staffNS' willBeModified='false'/> |
| <createXPathEvaluator var='xpEvaluator' document='doc'/> |
| <createExpression interface="XPathEvaluator" |
| obj='xpEvaluator' |
| var='xpathExpression' |
| expression='"//foo"' |
| resolver='nullNSResolver' |
| /> |
| <createEntityReference var="contextNode" obj="doc" name=""entityname""/> |
| <assertDOMException id="throw_NOT_SUPPORTED_ERR"> |
| <NOT_SUPPORTED_ERR> |
| <evaluate interface="XPathExpression" |
| obj='xpathExpression' |
| var='result' |
| contextNode='contextNode' |
| type='0' |
| result='nullResult'/> |
| </NOT_SUPPORTED_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathExpression_evaluate_WRONG_DOCUMENT_ERR.xml |
|---|
| 0,0 → 1,66 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathExpression_evaluate_WRONG_DOCUMENT_ERR"> |
| <metadata> |
| <title>XPathExpression_evaluate_WRONG_DOCUMENT_ERR</title> |
| <creator>Philippe Le Hégaret</creator> |
| <contributor>Bob Clary</contributor> |
| <description> |
| Test if XPathExpression.evaluate properly throws WRONG_DOCUMENT_ERROR |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathExpression-evaluate"/> |
| </metadata> |
| <var name='doc1' type='Document'/> |
| <var name='doc2' type='Document'/> |
| <var name='xpEvaluator' type='XPathEvaluator'/> |
| <var name="root" type='Element'/> |
| <var name="result" type="XPathResult"/> |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| <var name="xpathExpression" type="XPathExpression"/> |
| <load var='doc1' href='staffNS' willBeModified='false'/> |
| <load var='doc2' href='staff' willBeModified='false'/> |
| <createXPathEvaluator var='xpEvaluator' document='doc1'/> |
| <createExpression interface="XPathEvaluator" |
| obj='xpEvaluator' |
| var='xpathExpression' |
| expression='"//foo"' |
| resolver='nullNSResolver' |
| /> |
| <documentElement obj='doc2' var='root'/> |
| <assertDOMException id="throw_WRONG_DOCUMENT_ERR"> |
| <WRONG_DOCUMENT_ERR> |
| <evaluate interface="XPathExpression" |
| obj='xpathExpression' |
| var='result' |
| contextNode='root' |
| type='0' |
| result='nullResult'/> |
| </WRONG_DOCUMENT_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathExpression_evaluate_document.xml |
|---|
| 0,0 → 1,58 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathExpression_evaluate_document"> |
| <metadata> |
| <title>XPathExpression_evaluate_document</title> |
| <creator>Philippe Le Hégaret</creator> |
| <description> |
| Test if XPathExpression.evaluate returns non-null result |
| using Document as contextNode. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathExpression-evaluate"/> |
| </metadata> |
| &vars; |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="contextNode" type='Element'/> |
| <var name="xpathResult" type="XPathResult"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| <var name="xpathExpression" type="XPathExpression"/> |
| <var name="expression" type="DOMString" value=""/""/> |
| &findXPathEvaluator; |
| <assign value='doc' var='contextNode'/> |
| <createExpression interface="XPathEvaluator" |
| obj='xpEvaluator' |
| var='xpathExpression' |
| expression='expression' |
| resolver='nullNSResolver' |
| /> |
| <evaluate interface="XPathExpression" |
| obj='xpathExpression' |
| var='xpathResult' |
| contextNode='contextNode' |
| type='0' |
| result='nullResult'/> |
| <assertNotNull actual="xpathResult" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathExpression_evaluate_documentElement.xml |
|---|
| 0,0 → 1,62 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathExpression_evaluate_documentElement"> |
| <metadata> |
| <title>XPathExpression_evaluate_documentElement</title> |
| <creator>Philippe Le Hégaret</creator> |
| <creator>Bob Clary</creator> |
| <description> |
| Test if XPathExpression.evaluate returns non-null result |
| using Document.documentElement as contextNode. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathExpression-evaluate"/> |
| <subject resource="&spec;#XPathEvaluator-createExpression"/> |
| </metadata> |
| &vars; |
| <var name="nullNSResolver" type="XPathNSResolver" isNull="true"/> |
| <var name="contextNode" type='Element'/> |
| <var name="xpathResult" type="XPathResult"/> |
| <var name="nullResult" type="XPathResult" isNull="true"/> |
| <var name="xpathExpression" type="XPathExpression"/> |
| <var name="expression" type="DOMString" value=""/""/> |
| &findXPathEvaluator; |
| <documentElement obj='doc' var='contextNode'/> |
| <createExpression interface="XPathEvaluator" |
| obj='xpEvaluator' |
| var='xpathExpression' |
| expression='expression' |
| resolver='nullNSResolver' |
| /> |
| <evaluate interface="XPathExpression" |
| obj='xpathExpression' |
| var='xpathResult' |
| contextNode='contextNode' |
| type='0' |
| result='nullResult'/> |
| <assertNotNull actual="xpathResult" id="notnull"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathNSResolver_lookupNamespaceURI_nist_dmstc.xml |
|---|
| 0,0 → 1,119 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathNSResolver_lookupNamespaceURI_nist_dmstc"> |
| <metadata> |
| <title>XPathNSResolver_lookupNamespaceURI_nist_dmstc</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Interate over all employee elements with xmlns:dmstc attribute |
| in the test document, creating nsresolvers checking that |
| for all children the prefix 'nist' resolves to |
| http://www.nist.gov and that prefix 'dmstc' resolves to the same |
| value as employee.getAttribute('xmlns:dmstc'). |
| </description> |
| <date qualifier="created">2003-12-09</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathNSResolver-lookupNamespaceURI"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <!-- Test Variables --> |
| <var name="lookupNamespaceURI" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="child" type="Element"/> |
| <var name="children" type="NodeList"/> |
| <var name="employee" type="Element"/> |
| <var name="employees" type="NodeList"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <getElementsByTagNameNS obj="doc" |
| interface="Document" |
| var="employees" |
| namespaceURI=""*"" |
| localName=""employee"" |
| /> |
| <createXPathEvaluator var='evaluator' |
| document='doc'/> |
| <for-each member="employee" |
| collection="employees"> |
| <getAttribute obj="employee" |
| interface="Element" |
| name=""xmlns:dmstc"" |
| var="namespaceURI" |
| /> |
| <getElementsByTagNameNS obj="employee" |
| interface="Element" |
| var="children" |
| namespaceURI=""*"" |
| localName=""*"" |
| /> |
| <for-each member="child" |
| collection="children"> |
| <createNSResolver obj="evaluator" |
| var="resolver" |
| nodeResolver="child" |
| /> |
| <lookupNamespaceURI obj="resolver" |
| interface="XPathNSResolver" |
| var="lookupNamespaceURI" |
| prefix=""dmstc"" |
| /> |
| <assertEquals id="dmstcequal" |
| actual="lookupNamespaceURI" |
| expected="namespaceURI" |
| ignoreCase="false" |
| /> |
| <lookupNamespaceURI obj="resolver" |
| interface="XPathNSResolver" |
| var="lookupNamespaceURI" |
| prefix=""nist"" |
| /> |
| <assertEquals id="nistequal" |
| actual="lookupNamespaceURI" |
| expected=""http://www.nist.gov"" |
| ignoreCase="false" |
| /> |
| </for-each> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathNSResolver_lookupNamespaceURI_null.xml |
|---|
| 0,0 → 1,86 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2004 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathNSResolver_lookupNamespaceURI_null"> |
| <metadata> |
| <title>XPathNSResolver_lookupNamespaceURI_null</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Iterate over all elements in the test document, creating |
| nsresolvers checking that looking up non-existent prefixes |
| always returns null. |
| </description> |
| <date qualifier="created">2004-12-09</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathNSResolver-lookupNamespaceURI"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <!-- Test Variables --> |
| <var name="element" type="Element"/> |
| <var name="elements" type="NodeList"/> |
| <var name="lookupNamespaceURI" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="prefix" type="DOMString"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <!-- Test Body --> |
| <getElementsByTagNameNS obj="doc" |
| interface="Document" |
| var="elements" |
| namespaceURI=""*"" |
| localName=""*"" |
| /> |
| <createXPathEvaluator var='evaluator' |
| document='doc'/> |
| <for-each member="element" |
| collection="elements"> |
| <createNSResolver obj="evaluator" |
| var="resolver" |
| nodeResolver="element" |
| /> |
| <lookupNamespaceURI obj="resolver" |
| interface="XPathNSResolver" |
| var="lookupNamespaceURI" |
| prefix=""foobar"" |
| /> |
| <assertNull id="notnull" |
| actual="lookupNamespaceURI" |
| /> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathNSResolver_lookupNamespaceURI_prefix.xml |
|---|
| 0,0 → 1,99 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathNSResolver_lookupNamespaceURI_prefix"> |
| <metadata> |
| <title>XPathNSResolver_lookupNamespaceURI_prefix</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Iterate over all Elements in the test document, creating |
| nsresolvers checking that if the Element has a prefix, then |
| lookupNamespaceURI returns the same value as Element.namespaceURI |
| </description> |
| <date qualifier="created">2003-12-09</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathNSResolver-lookupNamespaceURI"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <!-- Test Variables --> |
| <var name="element" type="Element"/> |
| <var name="elements" type="NodeList"/> |
| <var name="lookupNamespaceURI" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="prefix" type="DOMString"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <!-- Test Body --> |
| <getElementsByTagNameNS obj="doc" |
| interface="Document" |
| var="elements" |
| namespaceURI=""*"" |
| localName=""*"" |
| /> |
| <createXPathEvaluator var='evaluator' |
| document='doc'/> |
| <for-each member="element" |
| collection="elements"> |
| <prefix obj="element" |
| var="prefix"/> |
| <if> |
| <notNull obj="prefix"/> |
| <createNSResolver obj="evaluator" |
| var="resolver" |
| nodeResolver="element" |
| /> |
| <namespaceURI obj="element" |
| interface="Node" |
| var="namespaceURI" |
| /> |
| <lookupNamespaceURI obj="resolver" |
| interface="XPathNSResolver" |
| var="lookupNamespaceURI" |
| prefix="prefix" |
| /> |
| <assertEquals id="equal" |
| actual="namespaceURI" |
| expected="lookupNamespaceURI" |
| ignoreCase="false" |
| /> |
| </if> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathNSResolver_lookupNamespaceURI_xml.xml |
|---|
| 0,0 → 1,88 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathNSResolver_lookupNamespaceURI_xml"> |
| <metadata> |
| <title>XPathNSResolver_lookupNamespaceURI_xml</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Iterate over all elements in the test document, creating |
| nsresolvers checking that looking up the xml prefix returns |
| http://www.w3.org/XML/1998/namespace. |
| </description> |
| <date qualifier="created">2003-12-09</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathNSResolver-lookupNamespaceURI"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <!-- Test Variables --> |
| <var name="element" type="Element"/> |
| <var name="elements" type="NodeList"/> |
| <var name="lookupNamespaceURI" type="DOMString"/> |
| <var name="namespaceURI" type="DOMString"/> |
| <var name="prefix" type="DOMString"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staffNS" willBeModified="false"/> |
| <!-- Test Body --> |
| <getElementsByTagNameNS obj="doc" |
| interface="Document" |
| var="elements" |
| namespaceURI=""*"" |
| localName=""*"" |
| /> |
| <createXPathEvaluator var='evaluator' |
| document='doc'/> |
| <for-each member="element" |
| collection="elements"> |
| <createNSResolver obj="evaluator" |
| var="resolver" |
| nodeResolver="element" |
| /> |
| <lookupNamespaceURI obj="resolver" |
| interface="XPathNSResolver" |
| var="lookupNamespaceURI" |
| prefix=""xml"" |
| /> |
| <assertEquals id="equal" |
| actual="lookupNamespaceURI" |
| expected=""http://www.w3.org/XML/1998/namespace"" |
| ignoreCase="false" |
| /> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_TYPE_ERR.xml |
|---|
| 0,0 → 1,457 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_TYPE_ERR"> |
| <metadata> |
| <title>XPathResult_TYPE_ERR</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult for the expression /staff/employee |
| for each type of XPathResultType, checking that TYPE_ERR |
| is thrown when inappropriate properties and methods are accessed. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#TYPE_ERR"/> |
| <subject resource="&spec;#XPathException"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathResult-resultType"/> |
| <subject resource="&spec;#XPathResult-booleanValue"/> |
| <subject resource="&spec;#XPathResult-numberValue"/> |
| <subject resource="&spec;#XPathResult-singleNodeValue"/> |
| <subject resource="&spec;#XPathResult-snapshot-length"/> |
| <subject resource="&spec;#XPathResult-stringValue"/> |
| <subject resource="&spec;#XPathResult-iterateNext"/> |
| <subject resource="&spec;#XPathResult-snapshotItem"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="resolver" type="XPathNSResolver"/> |
| <var name="evaluator" type="XPathEvaluator"/> |
| <var name="expression" type="DOMString" |
| value=""/staff/employee""/> |
| <var name="contextNode" type="Node"/> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <var name="inNodeType" type="short"/> |
| <var name="outNodeType" type="short"/> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="booleanValue" type="boolean"/> |
| <var name="shortValue" type="short"/> |
| <var name="intValue" type="int"/> |
| <var name="doubleValue" type="double"/> |
| <var name="nodeValue" type="Node"/> |
| <var name="stringValue" type="DOMString"/> |
| <var name="nodeTypeList" type="List"> |
| <member type="short">0</member> |
| <member type="short">1</member> |
| <member type="short">2</member> |
| <member type="short">3</member> |
| <member type="short">4</member> |
| <member type="short">5</member> |
| <member type="short">6</member> |
| <member type="short">7</member> |
| <member type="short">8</member> |
| <member type="short">9</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <for-each collection="nodeTypeList" member="inNodeType"> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="inNodeType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <resultType obj="outresult" |
| var="outNodeType"/> |
| <if> |
| <equals expected="outNodeType" actual="NUMBER_TYPE"/> |
| <assertXPathException id="number_booleanValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <booleanValue obj="outresult" |
| var="booleanValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="number_singleNodeValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <singleNodeValue obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="number_snapshotLength_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotLength obj="outresult" |
| var="intValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="number_stringValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <stringValue obj="outresult" |
| var="stringValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="number_iterateNext_TYPE_ERR"> |
| <TYPE_ERR> |
| <iterateNext obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="number_snapshotItem_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotItem obj="outresult" |
| var="nodeValue" |
| index="0"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| </if> |
| <if> |
| <equals expected="outNodeType" actual="STRING_TYPE"/> |
| <assertXPathException id="string_booleanValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <booleanValue obj="outresult" |
| var="booleanValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="string_numberValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <numberValue obj="outresult" |
| var="doubleValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="string_singleNodeValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <singleNodeValue obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="string_snapshotLength_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotLength obj="outresult" |
| var="intValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="string_iterateNext_TYPE_ERR"> |
| <TYPE_ERR> |
| <iterateNext obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="string_snapshotItem_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotItem obj="outresult" |
| var="nodeValue" |
| index="0"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| </if> |
| <if> |
| <equals expected="outNodeType" actual="BOOLEAN_TYPE"/> |
| <assertXPathException id="boolean_numberValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <numberValue obj="outresult" |
| var="doubleValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="boolean_singleNodeValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <singleNodeValue obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="boolean_snapshotLength_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotLength obj="outresult" |
| var="intValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="boolean_stringValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <stringValue obj="outresult" |
| var="stringValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="boolean_iterateNext_TYPE_ERR"> |
| <TYPE_ERR> |
| <iterateNext obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="boolean_snapshotItem_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotItem obj="outresult" |
| var="nodeValue" |
| index="0"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| </if> |
| <if> |
| <equals expected="outNodeType" actual="UNORDERED_NODE_ITERATOR_TYPE"/> |
| <assertXPathException id="unordered_node_iterator_booleanValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <booleanValue obj="outresult" |
| var="booleanValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="unordered_node_iterator_numberValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <numberValue obj="outresult" |
| var="doubleValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="unordered_node_iterator_singleNodeValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <singleNodeValue obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="unordered_node_iterator_snapshotLength_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotLength obj="outresult" |
| var="intValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="unordered_node_iterator_stringValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <stringValue obj="outresult" |
| var="stringValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="unordered_node_iterator_snapshotItem_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotItem obj="outresult" |
| var="nodeValue" |
| index="0"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| </if> |
| <if> |
| <equals expected="outNodeType" actual="ORDERED_NODE_ITERATOR_TYPE"/> |
| <assertXPathException id="ordered_node_iterator_booleanValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <booleanValue obj="outresult" |
| var="booleanValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="ordered_node_iterator_numberValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <numberValue obj="outresult" |
| var="doubleValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="ordered_node_iterator_singleNodeValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <singleNodeValue obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="ordered_node_iterator_snapshotLength_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotLength obj="outresult" |
| var="intValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="ordered_node_iterator_stringValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <stringValue obj="outresult" |
| var="stringValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="ordered_node_iterator_snapshotItem_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotItem obj="outresult" |
| var="nodeValue" |
| index="0"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| </if> |
| <if> |
| <equals expected="outNodeType" actual="UNORDERED_NODE_SNAPSHOT_TYPE"/> |
| <assertXPathException id="unordered_node_snapshot_booleanValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <booleanValue obj="outresult" |
| var="booleanValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="unordered_node_snapshot_numberValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <numberValue obj="outresult" |
| var="doubleValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="unordered_node_snapshot_singleNodeValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <singleNodeValue obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="unordered_node_snapshot_stringValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <stringValue obj="outresult" |
| var="stringValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="unordered_node_snapshot_iterateNext_TYPE_ERR"> |
| <TYPE_ERR> |
| <iterateNext obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| </if> |
| <if> |
| <equals expected="outNodeType" actual="ORDERED_NODE_SNAPSHOT_TYPE"/> |
| <assertXPathException id="ordered_node_snapshot_booleanValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <booleanValue obj="outresult" |
| var="booleanValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="ordered_node_snapshot_numberValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <numberValue obj="outresult" |
| var="doubleValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="ordered_node_snapshot_singleNodeValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <singleNodeValue obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="ordered_node_snapshot_stringValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <stringValue obj="outresult" |
| var="stringValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="ordered_node_snapshot_iterateNext_TYPE_ERR"> |
| <TYPE_ERR> |
| <iterateNext obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| </if> |
| <if> |
| <equals expected="outNodeType" actual="ANY_UNORDERED_NODE_TYPE"/> |
| <assertXPathException id="any_unordered_node_booleanValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <booleanValue obj="outresult" |
| var="booleanValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="any_unordered_node_numberValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <numberValue obj="outresult" |
| var="doubleValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="any_unordered_node_snapshotLength_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotLength obj="outresult" |
| var="intValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="any_unordered_node_stringValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <stringValue obj="outresult" |
| var="stringValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="any_unordered_node_iterateNext_TYPE_ERR"> |
| <TYPE_ERR> |
| <iterateNext obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="any_unordered_node_snapshotItem_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotItem obj="outresult" |
| var="nodeValue" |
| index="0"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| </if> |
| <if> |
| <equals expected="outNodeType" actual="FIRST_ORDERED_NODE_TYPE"/> |
| <assertXPathException id="first_ordered_node_booleanValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <booleanValue obj="outresult" |
| var="booleanValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="first_ordered_node_numberValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <numberValue obj="outresult" |
| var="doubleValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="first_ordered_node_snapshotLength_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotLength obj="outresult" |
| var="intValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="first_ordered_node_stringValue_TYPE_ERR"> |
| <TYPE_ERR> |
| <stringValue obj="outresult" |
| var="stringValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="first_ordered_node_iterateNext_TYPE_ERR"> |
| <TYPE_ERR> |
| <iterateNext obj="outresult" |
| var="nodeValue"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| <assertXPathException id="first_ordered_node_snapshotItem_TYPE_ERR"> |
| <TYPE_ERR> |
| <snapshotItem obj="outresult" |
| var="nodeValue" |
| index="0"/> |
| </TYPE_ERR> |
| </assertXPathException> |
| </if> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_booleanValue_false.xml |
|---|
| 0,0 → 1,100 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_booleanValue_false"> |
| <metadata> |
| <title>XPathResult_booleanValue_false</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create BOOLEAN_TYPE XPathResult matching /staff/workerbee, |
| checking that XPathResult.booleanValue == false |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResult-booleanValue"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/workerbee""/> |
| <var name="xpathType" type="short" value="BOOLEAN_TYPE" /> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="parent" type="Node"/> |
| <var name="owner" type="Node"/> |
| <var name="ownerType" type="int"/> |
| <var name="booleanValue" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <booleanValue obj="outresult" |
| var="booleanValue" |
| /> |
| <assertFalse id="false" |
| actual="booleanValue" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_booleanValue_true.xml |
|---|
| 0,0 → 1,100 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_booleanValue_true"> |
| <metadata> |
| <title>XPathResult_booleanValue_true</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create BOOLEAN_TYPE XPathResult matching /staff/employee, |
| checking that XPathResult.booleanValue == true |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResult-booleanValue"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="BOOLEAN_TYPE" /> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="parent" type="Node"/> |
| <var name="owner" type="Node"/> |
| <var name="ownerType" type="int"/> |
| <var name="booleanValue" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <booleanValue obj="outresult" |
| var="booleanValue" |
| /> |
| <assertTrue id="true" |
| actual="booleanValue" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_invalidIteratorState_ANY_TYPE.xml |
|---|
| 0,0 → 1,108 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_invalidIteratorState_ANY_TYPE"> |
| <metadata> |
| <title>XPathResult_invalidIteratorState_ANY_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a ANY_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that iterator XPathResults |
| are invalidated XPathResult.invalidIteratorState == true. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-invalid-iterator-state"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="ANY_TYPE" /> |
| <!-- Test Variables --> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <var name="invalidIteratorState" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertTrue id="true" |
| actual="invalidIteratorState" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_invalidIteratorState_ANY_UNORDERED_NODE_TYPE.xml |
|---|
| 0,0 → 1,108 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_invalidIteratorState_ANY_UNORDERED_NODE_TYPE"> |
| <metadata> |
| <title>XPathResult_invalidIteratorState_ANY_UNORDERED_NODE_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a ANY_UNORDERED_NODE_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that iterator XPathResults |
| are not invalidated XPathResult.invalidIteratorState == false. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-invalid-iterator-state"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="ANY_UNORDERED_NODE_TYPE" /> |
| <!-- Test Variables --> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <var name="invalidIteratorState" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertFalse id="false" |
| actual="invalidIteratorState" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_invalidIteratorState_BOOLEAN_TYPE.xml |
|---|
| 0,0 → 1,108 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_invalidIteratorState_BOOLEAN_TYPE"> |
| <metadata> |
| <title>XPathResult_invalidIteratorState_BOOLEAN_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a BOOLEAN_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that iterator XPathResults |
| are not invalidated XPathResult.invalidIteratorState == false. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-invalid-iterator-state"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="BOOLEAN_TYPE" /> |
| <!-- Test Variables --> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <var name="invalidIteratorState" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertFalse id="false" |
| actual="invalidIteratorState" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_invalidIteratorState_FIRST_ORDERED_NODE_TYPE.xml |
|---|
| 0,0 → 1,108 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_invalidIteratorState_FIRST_ORDERED_NODE_TYPE"> |
| <metadata> |
| <title>XPathResult_invalidIteratorState_FIRST_ORDERED_NODE_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a FIRST_ORDERED_NODE_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that iterator XPathResults |
| are not invalidated XPathResult.invalidIteratorState == false. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-invalid-iterator-state"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="FIRST_ORDERED_NODE_TYPE" /> |
| <!-- Test Variables --> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <var name="invalidIteratorState" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertFalse id="false" |
| actual="invalidIteratorState" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_invalidIteratorState_NUMBER_TYPE.xml |
|---|
| 0,0 → 1,108 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_invalidIteratorState_NUMBER_TYPE"> |
| <metadata> |
| <title>XPathResult_invalidIteratorState_NUMBER_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a NUMBER_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that iterator XPathResults |
| are not invalidated XPathResult.invalidIteratorState == false. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-invalid-iterator-state"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="NUMBER_TYPE" /> |
| <!-- Test Variables --> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <var name="invalidIteratorState" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertFalse id="false" |
| actual="invalidIteratorState" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_invalidIteratorState_ORDERED_NODE_ITERATOR_TYPE.xml |
|---|
| 0,0 → 1,116 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_invalidIteratorState_ORDERED_NODE_ITERATOR_TYPE"> |
| <metadata> |
| <title>XPathResult_invalidIteratorState_ORDERED_NODE_ITERATOR_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a ORDERED_NODE_ITERATOR_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that iterator XPathResults |
| are invalidated XPathResult.invalidIteratorState == true. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-invalid-iterator-state"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="ORDERED_NODE_ITERATOR_TYPE" /> |
| <!-- Test Variables --> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <var name="invalidIteratorState" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertFalse id="false" |
| actual="invalidIteratorState" |
| /> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertTrue id="true" |
| actual="invalidIteratorState" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_invalidIteratorState_ORDERED_NODE_SNAPSHOT_TYPE.xml |
|---|
| 0,0 → 1,108 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_invalidIteratorState_ORDERED_NODE_SNAPSHOT_TYPE"> |
| <metadata> |
| <title>XPathResult_invalidIteratorState_ORDERED_NODE_SNAPSHOT_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a ORDERED_NODE_SNAPSHOT_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that iterator XPathResults |
| are not invalidated XPathResult.invalidIteratorState == false. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-invalid-iterator-state"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="ORDERED_NODE_SNAPSHOT_TYPE" /> |
| <!-- Test Variables --> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <var name="invalidIteratorState" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertFalse id="false" |
| actual="invalidIteratorState" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_invalidIteratorState_STRING_TYPE.xml |
|---|
| 0,0 → 1,108 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_invalidIteratorState_STRING_TYPE"> |
| <metadata> |
| <title>XPathResult_invalidIteratorState_STRING_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a STRING_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that iterator XPathResults |
| are not invalidated XPathResult.invalidIteratorState == false. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-invalid-iterator-state"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="STRING_TYPE" /> |
| <!-- Test Variables --> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <var name="invalidIteratorState" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertFalse id="false" |
| actual="invalidIteratorState" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_invalidIteratorState_UNORDERED_NODE_ITERATOR_TYPE.xml |
|---|
| 0,0 → 1,116 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_invalidIteratorState_UNORDERED_NODE_ITERATOR_TYPE"> |
| <metadata> |
| <title>XPathResult_invalidIteratorState_UNORDERED_NODE_ITERATOR_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a UNORDERED_NODE_ITERATOR_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that iterator XPathResults |
| are invalidated XPathResult.invalidIteratorState == true. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-invalid-iterator-state"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="UNORDERED_NODE_ITERATOR_TYPE" /> |
| <!-- Test Variables --> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <var name="invalidIteratorState" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertFalse id="false" |
| actual="invalidIteratorState" |
| /> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertTrue id="true" |
| actual="invalidIteratorState" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_invalidIteratorState_UNORDERED_NODE_SNAPSHOT_TYPE.xml |
|---|
| 0,0 → 1,108 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_invalidIteratorState_UNORDERED_NODE_SNAPSHOT_TYPE"> |
| <metadata> |
| <title>XPathResult_invalidIteratorState_UNORDERED_NODE_SNAPSHOT_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a UNORDERED_NODE_SNAPSHOT_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that iterator XPathResults |
| are not invalidated XPathResult.invalidIteratorState == false. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult-invalid-iterator-state"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="UNORDERED_NODE_SNAPSHOT_TYPE" /> |
| <!-- Test Variables --> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <var name="invalidIteratorState" type="boolean"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <invalidIteratorState obj="outresult" |
| var="invalidIteratorState" |
| /> |
| <assertFalse id="false" |
| actual="invalidIteratorState" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_iterateNext_INVALID_STATE_ERR.xml |
|---|
| 0,0 → 1,113 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_iterateNext_INVALID_STATE_ERR"> |
| <metadata> |
| <title>XPathResult_iterateNext_INVALID_STATE_ERR</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create a ANY_TYPE XPathResult matching /staff/employee, |
| modify the Document, then check that XPathResults.iterateNext |
| throws DOMException INVALID_STATE_ERR. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathEvaluator"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathNSResolver"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResult-iterateNext"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="xpathType" type="short" value="ANY_TYPE" /> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="parent" type="Node"/> |
| <var name="owner" type="Node"/> |
| <var name="ownerType" type="int"/> |
| <var name="employee" type="Node"/> |
| <var name="docElement" type="Node"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="true"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <!-- Test Body --> |
| <documentElement obj="doc" |
| var="docElement"/> |
| <createElement obj="doc" |
| var="employee" |
| tagName=""employee""/> |
| <appendChild obj="docElement" |
| newChild="employee" |
| var="employee"/> |
| <assertDOMException id="throw_INVALID_STATE_ERR"> |
| <INVALID_STATE_ERR> |
| <iterateNext var="outNode" obj="outresult"/> |
| </INVALID_STATE_ERR> |
| </assertDOMException> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_iteratorNext_ORDERED_NODE_ITERATOR_TYPE.xml |
|---|
| 0,0 → 1,160 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_iteratorNext_ORDERED_NODE_ITERATOR_TYPE"> |
| <metadata> |
| <title>XPathResult_iteratorNext_ORDERED_NODE_ITERATOR_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult ORDERED_NODE_ITERATOR_TYPE XPathResultType for |
| expression /staff/employee/employeeId/text() checking that: |
| XPathResult.iteratorNext returns the nodes in document order, |
| and that the correct number is returned. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult-iteratorNext"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/employeeId/text()""/> |
| <var name="xpathType" type="short" value="ORDERED_NODE_ITERATOR_TYPE" /> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <var name="index" type="int"/> |
| <var name="text" type="DOMString" /> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <assign var="index" |
| value="0" |
| /> |
| <iterateNext var="outNode" obj="outresult"/> |
| <while> |
| <notNull obj="outNode"/> |
| <data obj="outNode" |
| interface="CharacterData" |
| var="text" |
| /> |
| <if><equals actual="index" expected="0" /> |
| <assertEquals id="first" |
| actual="text" |
| expected=""EMP0001"" |
| ignoreCase="false" |
| /> |
| </if> |
| <if><equals actual="index" expected="1" /> |
| <assertEquals id="second" |
| actual="text" |
| expected=""EMP0002"" |
| ignoreCase="false" |
| /> |
| </if> |
| <if><equals actual="index" expected="2" /> |
| <assertEquals id="third" |
| actual="text" |
| expected=""EMP0003"" |
| ignoreCase="false" |
| /> |
| </if> |
| <if><equals actual="index" expected="3" /> |
| <assertEquals id="fourth" |
| actual="text" |
| expected=""EMP0004"" |
| ignoreCase="false" |
| /> |
| </if> |
| <if><equals actual="index" expected="4" /> |
| <assertEquals id="fifth" |
| actual="text" |
| expected=""EMP0005"" |
| ignoreCase="false" |
| /> |
| </if> |
| <increment var="index" |
| value="1" |
| /> |
| <iterateNext var="outNode" obj="outresult"/> |
| </while> |
| <assertEquals id="count" |
| actual="index" |
| expected="5" |
| ignoreCase="false" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_iteratorNext_UNORDERED_NODE_ITERATOR_TYPE.xml |
|---|
| 0,0 → 1,112 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_iteratorNext_UNORDERED_NODE_ITERATOR_TYPE"> |
| <metadata> |
| <title>XPathResult_iteratorNext_UNORDERED_NODE_ITERATOR_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult UNORDERED_NODE_ITERATOR_TYPE XPathResultType for |
| expression /staff/employee/employeeId/text() checking that: |
| XPathResult.iteratorNext contains the correct number of nodes. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult-iteratorNext"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/employeeId/text()""/> |
| <var name="xpathType" type="short" value="UNORDERED_NODE_ITERATOR_TYPE" /> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <var name="nodeType" type="int"/> |
| <var name="parent" type="Node"/> |
| <var name="owner" type="Node"/> |
| <var name="ownerType" type="int"/> |
| <var name="index" type="int"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <assign var="index" |
| value="0" |
| /> |
| <iterateNext var="outNode" obj="outresult"/> |
| <while> |
| <notNull obj="outNode"/> |
| <increment var="index" |
| value="1" |
| /> |
| <iterateNext var="outNode" obj="outresult"/> |
| </while> |
| <assertEquals id="count" |
| actual="index" |
| expected="4" |
| ignoreCase="false" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_numberValue.xml |
|---|
| 0,0 → 1,95 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_numberValue"> |
| <metadata> |
| <title>XPathResult_numberValue</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult NUMBER_VALUE XPathResultType for expression |
| /staff/employee/salary[text() = '56,000'] checking that the |
| XPathResult.numberValue == 56.0 |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult-numberValue"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""substring-before(/staff/employee/salary[text() = '56,000'], ',')""/> |
| <var name="xpathType" type="short" value="NUMBER_TYPE" /> |
| <!-- Test Variables --> |
| <var name="numberValue" type="double"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <numberValue obj="outresult" |
| var="numberValue" |
| /> |
| <assertEquals id="same" |
| actual="numberValue" |
| expected="56.0" |
| ignoreCase="false" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_resultType.xml |
|---|
| 0,0 → 1,179 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_resultType"> |
| <metadata> |
| <title>XPathResult_resultType</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult for the expression /staff/employee |
| for each type of XPathResultType, checking that the resultType |
| of the XPathResult matches the requested type. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| <subject resource="&spec;#XPathEvaluator-evaluate"/> |
| <subject resource="&spec;#XPathResult-resultType"/> |
| <subject resource="&spec;#XPathException"/> |
| </metadata> |
| <var name="doc" type="Document"/> |
| <var name="resolver" type="XPathNSResolver"/> |
| <var name="evaluator" type="XPathEvaluator"/> |
| <var name="expression" type="DOMString" value=""/staff/employee""/> |
| <var name="contextNode" type="Node"/> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <var name="inNodeType" type="short"/> |
| <var name="outNodeType" type="short"/> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="isTypeEqual" type="boolean"/> |
| <var name="nodeTypeList" type="List"> |
| <member type="short">0</member> |
| <member type="short">1</member> |
| <member type="short">2</member> |
| <member type="short">3</member> |
| <member type="short">4</member> |
| <member type="short">5</member> |
| <member type="short">6</member> |
| <member type="short">7</member> |
| <member type="short">8</member> |
| <member type="short">9</member> |
| </var> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <for-each collection="nodeTypeList" member="inNodeType"> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="inNodeType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <resultType obj="outresult" |
| var="outNodeType"/> |
| <if> |
| <equals expected="inNodeType" actual="ANY_TYPE"/> |
| <assertEquals id="ANY_TYPE_resulttype" |
| actual="outNodeType" |
| expected="UNORDERED_NODE_ITERATOR_TYPE" |
| ignoreCase="false" |
| /> |
| </if> |
| <if> |
| <equals expected="inNodeType" actual="NUMBER_TYPE"/> |
| <assertEquals id="NUMBER_TYPE_resulttype" |
| actual="outNodeType" |
| expected="NUMBER_TYPE" |
| ignoreCase="false" |
| /> |
| </if> |
| <if> |
| <equals expected="inNodeType" actual="STRING_TYPE"/> |
| <assertEquals id="STRING_TYPE_resulttype" |
| actual="outNodeType" |
| expected="STRING_TYPE" |
| ignoreCase="false" |
| /> |
| </if> |
| <if> |
| <equals expected="inNodeType" actual="BOOLEAN_TYPE"/> |
| <assertEquals id="BOOLEAN_TYPE_resulttype" |
| actual="outNodeType" |
| expected="BOOLEAN_TYPE" |
| ignoreCase="false" |
| /> |
| </if> |
| <if> |
| <equals expected="inNodeType" actual="UNORDERED_NODE_ITERATOR_TYPE"/> |
| <assertEquals id="UNORDERED_NODE_ITERATOR_TYPE_resulttype" |
| actual="outNodeType" |
| expected="UNORDERED_NODE_ITERATOR_TYPE" |
| ignoreCase="false" |
| /> |
| </if> |
| <if> |
| <equals expected="inNodeType" actual="ORDERED_NODE_ITERATOR_TYPE"/> |
| <assertEquals id="ORDERED_NODE_ITERATOR_TYPE_resulttype" |
| actual="outNodeType" |
| expected="ORDERED_NODE_ITERATOR_TYPE" |
| ignoreCase="false" |
| /> |
| </if> |
| <if> |
| <equals expected="inNodeType" actual="UNORDERED_NODE_SNAPSHOT_TYPE"/> |
| <assertEquals id="UNORDERED_NODE_SNAPSHOT_TYPE_resulttype" |
| actual="outNodeType" |
| expected="UNORDERED_NODE_SNAPSHOT_TYPE" |
| ignoreCase="false" |
| /> |
| </if> |
| <if> |
| <equals expected="inNodeType" actual="ORDERED_NODE_SNAPSHOT_TYPE"/> |
| <assertEquals id="ORDERED_NODE_SNAPSHOT_TYPE_resulttype" |
| actual="outNodeType" |
| expected="ORDERED_NODE_SNAPSHOT_TYPE" |
| ignoreCase="false" |
| /> |
| </if> |
| <if> |
| <equals expected="inNodeType" actual="ANY_UNORDERED_NODE_TYPE"/> |
| <assertEquals id="ANY_UNORDERED_NODE_TYPE_resulttype" |
| actual="outNodeType" |
| expected="ANY_UNORDERED_NODE_TYPE" |
| ignoreCase="false" |
| /> |
| </if> |
| <if> |
| <equals expected="inNodeType" actual="FIRST_ORDERED_NODE_TYPE"/> |
| <assertEquals id="FIRST_ORDERED_NODE_TYPE_resulttype" |
| actual="outNodeType" |
| expected="FIRST_ORDERED_NODE_TYPE" |
| ignoreCase="false" |
| /> |
| </if> |
| </for-each> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_singleNodeValue_ANY_UNORDERED_NODE_TYPE.xml |
|---|
| 0,0 → 1,99 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_singleNodeValue_ANY_UNORDERED_NODE_TYPE"> |
| <metadata> |
| <title>XPathResult_singleNodeValue_ANY_UNORDERED_NODE_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create ANY_UNORDERED_NODE_TYPE XPathResult matching /staff/employee/employeeId, |
| checking that XPathResult.singleNodeValue matches. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/employeeId""/> |
| <var name="xpathType" type="short" value="ANY_UNORDERED_NODE_TYPE" /> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <var name="employeeId" type="Node"/> |
| <var name="localName" type="DOMString"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <singleNodeValue obj="outresult" |
| var="outNode" |
| /> |
| <localName obj="outNode" |
| var="localName" |
| /> |
| <assertEquals id="equals" |
| actual="localName" |
| expected=""employeeId"" |
| ignoreCase="false" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_singleNodeValue_FIRST_ORDERED_NODE_TYPE.xml |
|---|
| 0,0 → 1,100 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_singleNodeValue_FIRST_ORDERED_NODE_TYPE"> |
| <metadata> |
| <title>XPathResult_singleNodeValue_FIRST_ORDERED_NODE_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create FIRST_ORDERED_NODE_TYPE XPathResult matching /staff/employee/employeeId/text(), |
| checking that XPathResult.singleNodeValue matches the first EMP0001. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/employeeId/text()""/> |
| <var name="xpathType" type="short" value="FIRST_ORDERED_NODE_TYPE" /> |
| <!-- Test Variables --> |
| <var name="outNode" type="Node"/> |
| <var name="data" type="DOMString"/> |
| <var name="nodeName" type="DOMString"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <singleNodeValue obj="outresult" |
| var="outNode" |
| /> |
| <data obj="outNode" |
| interface="CharacterData" |
| var="data" |
| /> |
| <assertEquals id="equals" |
| actual="data" |
| expected=""EMP0001"" |
| ignoreCase="false" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_snapshotItem_ORDERED_NODE_SNAPSHOT_TYPE_null.xml |
|---|
| 0,0 → 1,101 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_snapshotItem_ORDERED_NODE_SNAPSHOT_TYPE_null"> |
| <metadata> |
| <title>XPathResult_snapshotItem_ORDERED_NODE_SNAPSHOT_TYPE_null</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult ORDERED_NODE_SNAPSHOT_TYPE XPathResultType for |
| expression /staff/employee/employeeId/text() checking that: |
| XPathResult.snapshotItem(xPathResult.snapshotLength) == null, |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult-snapshot-length"/> |
| <subject resource="&spec;#XPathResult-snapshotItem"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/employeeId/text()""/> |
| <var name="xpathType" type="short" value="ORDERED_NODE_SNAPSHOT_TYPE" /> |
| <!-- Test Variables --> |
| <var name="snapshotItem" type="Node"/> |
| <var name="snapshotLength" type="int"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <snapshotLength obj="outresult" |
| var="snapshotLength" |
| /> |
| <snapshotItem obj="outresult" |
| var="snapshotItem" |
| index="snapshotLength" |
| /> |
| <assertNull id="null" |
| actual="snapshotItem" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_snapshotItem_ORDERED_NODE_SNAPSHOT_TYPE_order.xml |
|---|
| 0,0 → 1,151 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_snapshotItem_ORDERED_NODE_SNAPSHOT_TYPE_order"> |
| <metadata> |
| <title>XPathResult_snapshotItem_ORDERED_NODE_SNAPSHOT_TYPE_order</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult ORDERED_NODE_SNAPSHOT_TYPE XPathResultType for |
| expression /staff/employee/employeeId/text() checking that: |
| XPathResult.snapshotItem(0..3) are in document order. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult-snapshot-length"/> |
| <subject resource="&spec;#XPathResult-snapshotItem"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/employeeId/text()""/> |
| <var name="xpathType" type="short" value="ORDERED_NODE_SNAPSHOT_TYPE" /> |
| <!-- Test Variables --> |
| <var name="snapshotItem" type="Node"/> |
| <var name="snapshotLength" type="int"/> |
| <var name="index" type="int"/> |
| <var name="text" type="DOMString" /> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <assign var="index" |
| value="0" |
| /> |
| <while> |
| <less actual="index" |
| expected="4" |
| /> |
| <snapshotItem obj="outresult" |
| var="snapshotItem" |
| index="index" |
| /> |
| <data obj="snapshotItem" |
| interface="CharacterData" |
| var="text" |
| /> |
| <if><equals actual="index" expected="0" /> |
| <assertEquals id="first" |
| actual="text" |
| expected=""EMP0001"" |
| ignoreCase="false" |
| /> |
| </if> |
| <if><equals actual="index" expected="1" /> |
| <assertEquals id="second" |
| actual="text" |
| expected=""EMP0002"" |
| ignoreCase="false" |
| /> |
| </if> |
| <if><equals actual="index" expected="2" /> |
| <assertEquals id="third" |
| actual="text" |
| expected=""EMP0003"" |
| ignoreCase="false" |
| /> |
| </if> |
| <if><equals actual="index" expected="3" /> |
| <assertEquals id="fourth" |
| actual="text" |
| expected=""EMP0004"" |
| ignoreCase="false" |
| /> |
| </if> |
| <increment var="index" |
| value="1" |
| /> |
| </while> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_snapshotItem_UNORDERED_NODE_SNAPSHOT_TYPE_count.xml |
|---|
| 0,0 → 1,114 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_snapshotItem_UNORDERED_NODE_SNAPSHOT_TYPE_count"> |
| <metadata> |
| <title>XPathResult_snapshotItem_UNORDERED_NODE_SNAPSHOT_TYPE_count</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult UNORDERED_NODE_SNAPSHOT_TYPE XPathResultType for |
| expression /staff/employee/employeeId/text() checking that: |
| XPathResult.snapshotItem(0..3) exist. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult-snapshot-length"/> |
| <subject resource="&spec;#XPathResult-snapshotItem"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/employeeId/text()""/> |
| <var name="xpathType" type="short" value="UNORDERED_NODE_SNAPSHOT_TYPE" /> |
| <!-- Test Variables --> |
| <var name="snapshotItem" type="Node"/> |
| <var name="snapshotLength" type="int"/> |
| <var name="index" type="int"/> |
| <var name="text" type="DOMString" /> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <assign var="index" |
| value="0" |
| /> |
| <while> |
| <less actual="index" |
| expected="5" |
| /> |
| <snapshotItem obj="outresult" |
| var="snapshotItem" |
| index="index" |
| /> |
| <assertNotNull id="notnull" |
| actual="snapshotItem" |
| /> |
| <increment var="index" |
| value="1" |
| /> |
| </while> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_snapshotItem_UNORDERED_NODE_SNAPSHOT_TYPE_null.xml |
|---|
| 0,0 → 1,101 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_snapshotItem_UNORDERED_NODE_SNAPSHOT_TYPE_null"> |
| <metadata> |
| <title>XPathResult_snapshotItem_UNORDERED_NODE_SNAPSHOT_TYPE_null</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult UNORDERED_NODE_SNAPSHOT_TYPE XPathResultType for |
| expression /staff/employee/employeeId/text() checking that: |
| XPathResult.snapshotItem(xPathResult.snapshotLength) == null, |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult-snapshot-length"/> |
| <subject resource="&spec;#XPathResult-snapshotItem"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/employeeId/text()""/> |
| <var name="xpathType" type="short" value="UNORDERED_NODE_SNAPSHOT_TYPE" /> |
| <!-- Test Variables --> |
| <var name="snapshotItem" type="Node"/> |
| <var name="snapshotLength" type="int"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <snapshotLength obj="outresult" |
| var="snapshotLength" |
| /> |
| <snapshotItem obj="outresult" |
| var="snapshotItem" |
| index="snapshotLength" |
| /> |
| <assertNull id="null" |
| actual="snapshotItem" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_snapshotLength_ORDERED_NODE_SNAPSHOT_TYPE.xml |
|---|
| 0,0 → 1,98 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_snapshotLength_ORDERED_NODE_SNAPSHOT_TYPE"> |
| <metadata> |
| <title>XPathResult_snapshotLength_ORDERED_NODE_SNAPSHOT_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult ORDERED_NODE_SNAPSHOT_TYPE XPathResultType for |
| expression /staff/employee/employeeId/text() checking that: |
| XPathResult.snapshotLength is correct value. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult-snapshot-length"/> |
| <subject resource="&spec;#XPathResult-snapshotItem"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/employeeId/text()""/> |
| <var name="xpathType" type="short" value="ORDERED_NODE_SNAPSHOT_TYPE" /> |
| <!-- Test Variables --> |
| <var name="snapshotItem" type="Node"/> |
| <var name="snapshotLength" type="int"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <snapshotLength obj="outresult" |
| var="snapshotLength" |
| /> |
| <assertEquals id="same" |
| actual="snapshotLength" |
| expected="5" |
| ignoreCase="false" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_snapshotLength_UNORDERED_NODE_SNAPSHOT_TYPE.xml |
|---|
| 0,0 → 1,98 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_snapshotLength_UNORDERED_NODE_SNAPSHOT_TYPE"> |
| <metadata> |
| <title>XPathResult_snapshotLength_UNORDERED_NODE_SNAPSHOT_TYPE</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult UNORDERED_NODE_SNAPSHOT_TYPE XPathResultType for |
| expression /staff/employee/employeeId/text() checking that: |
| XPathResult.snapshotLength is correct value. |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult-snapshot-length"/> |
| <subject resource="&spec;#XPathResult-snapshotItem"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/employeeId/text()""/> |
| <var name="xpathType" type="short" value="UNORDERED_NODE_SNAPSHOT_TYPE" /> |
| <!-- Test Variables --> |
| <var name="snapshotItem" type="Node"/> |
| <var name="snapshotLength" type="int"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <snapshotLength obj="outresult" |
| var="snapshotLength" |
| /> |
| <assertEquals id="same" |
| actual="snapshotLength" |
| expected="5" |
| ignoreCase="false" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/XPathResult_stringValue.xml |
|---|
| 0,0 → 1,97 |
| <?xml version="1.0" encoding="iso-8859-1"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE test SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <test xmlns="&level3;" name="XPathResult_stringValue"> |
| <metadata> |
| <title>XPathResult_stringValue</title> |
| <creator>Bob Clary</creator> |
| <description> |
| Create an XPathResult STRING_VALUE XPathResultType for expression |
| /staff/employee/salary[text()='56,000'] checking that the |
| XPathResult.stringValue == "56,000" |
| </description> |
| <date qualifier="created">2003-12-02</date> |
| <subject resource="&spec;#XPathResult-stringValue"/> |
| <subject resource="&spec;#XPathResult"/> |
| <subject resource="&spec;#XPathResultType"/> |
| <subject resource="&spec;#XPathEvaluator-createNSResolver"/> |
| </metadata> |
| <!-- Standard Variables --> |
| <var name="ANY_TYPE" type="short" value="0"/> |
| <var name="NUMBER_TYPE" type="short" value="1"/> |
| <var name="STRING_TYPE" type="short" value="2"/> |
| <var name="BOOLEAN_TYPE" type="short" value="3"/> |
| <var name="UNORDERED_NODE_ITERATOR_TYPE" type="short" value="4"/> |
| <var name="ORDERED_NODE_ITERATOR_TYPE" type="short" value="5"/> |
| <var name="UNORDERED_NODE_SNAPSHOT_TYPE" type="short" value="6"/> |
| <var name="ORDERED_NODE_SNAPSHOT_TYPE" type="short" value="7"/> |
| <var name="ANY_UNORDERED_NODE_TYPE" type="short" value="8"/> |
| <var name="FIRST_ORDERED_NODE_TYPE" type="short" value="9"/> |
| <var name="doc" type="Document" /> |
| <var name="resolver" type="XPathNSResolver" /> |
| <var name="evaluator" type="XPathEvaluator" /> |
| <var name="contextNode" type="Node" /> |
| <var name="inresult" type="XPathResult" isNull="true"/> |
| <var name="outresult" type="XPathResult" isNull="true"/> |
| <!-- Inputs --> |
| <var name="expression" type="DOMString" value=""/staff/employee/salary[text()='56,000']""/> |
| <var name="xpathType" type="short" value="STRING_TYPE" /> |
| <!-- Test Variables --> |
| <var name="stringValue" type="DOMString"/> |
| <!-- Load Test Document --> |
| <load var="doc" href="staff" willBeModified="false"/> |
| <!-- Get XPathResult --> |
| <createXPathEvaluator var="evaluator" document="doc"/> |
| <createNSResolver obj="evaluator" var="resolver" nodeResolver="doc"/> |
| <assign var="contextNode" value="doc"/> |
| <evaluate obj="evaluator" |
| var="outresult" |
| expression="expression" |
| contextNode="contextNode" |
| resolver="resolver" |
| type="xpathType" |
| result="inresult" |
| interface="XPathEvaluator" |
| /> |
| <stringValue obj="outresult" |
| var="stringValue" |
| /> |
| <assertEquals id="same" |
| actual="stringValue" |
| expected=""56,000"" |
| ignoreCase="false" |
| /> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/alltests.xml |
|---|
| 0,0 → 1,89 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <?xml-stylesheet href="test-to-html.xsl" type="text/xml"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE suite SYSTEM "dom3.dtd" [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <suite xmlns="&level3;" name="alltests"> |
| <metadata> |
| <title>DOM Level 3 XPath Test Suite</title> |
| <creator>DOM Test Suite Project</creator> |
| </metadata> |
| <suite.member href="XPathEvaluatorCast01.xml"/> |
| <suite.member href="Element_Nodes.xml"/> |
| <suite.member href="Attribute_Nodes.xml"/> |
| <suite.member href="Attribute_Nodes_xmlns.xml"/> |
| <suite.member href="Text_Nodes.xml"/> |
| <suite.member href="Comment_Nodes.xml"/> |
| <suite.member href="Processing_Instruction_Nodes.xml"/> |
| <suite.member href="Conformance_Expressions.xml"/> |
| <suite.member href="Conformance_hasFeature_3.xml"/> |
| <suite.member href="Conformance_hasFeature_empty.xml"/> |
| <suite.member href="Conformance_hasFeature_null.xml"/> |
| <suite.member href="Conformance_ID.xml"/> |
| <suite.member href="Conformance_isSupported_3.xml"/> |
| <suite.member href="Conformance_isSupported_empty.xml"/> |
| <suite.member href="Conformance_isSupported_null.xml"/> |
| <suite.member href="XPathEvaluator_createExpression_no_NS.xml"/> |
| <suite.member href="XPathEvaluator_createExpression_NS.xml"/> |
| <suite.member href="XPathEvaluator_createExpression_NAMESPACE_ERR_01.xml"/> |
| <suite.member href="XPathEvaluator_createExpression_INVALID_EXPRESSION_ERR.xml"/> |
| <suite.member href="XPathEvaluator_createExpression_NAMESPACE_ERR_02.xml"/> |
| <suite.member href="XPathEvaluator_createNSResolver_document.xml"/> |
| <suite.member href="XPathEvaluator_createNSResolver_documentElement.xml"/> |
| <suite.member href="XPathEvaluator_createNSResolver_all.xml"/> |
| <suite.member href="XPathEvaluator_evaluate_documentElement.xml"/> |
| <suite.member href="XPathEvaluator_evaluate_document.xml"/> |
| <suite.member href="XPathEvaluator_evaluate_INVALID_EXPRESSION_ERR.xml"/> |
| <suite.member href="XPathEvaluator_evaluate_NAMESPACE_ERR.xml"/> |
| <suite.member href="XPathEvaluator_evaluate_WRONG_DOCUMENT_ERR.xml"/> |
| <suite.member href="XPathEvaluator_evaluate_NOT_SUPPORTED_ERR.xml"/> |
| <suite.member href="XPathEvaluator_evaluate_TYPE_ERR.xml"/> |
| <suite.member href="XPathExpression_evaluate_documentElement.xml"/> |
| <suite.member href="XPathExpression_evaluate_document.xml"/> |
| <suite.member href="XPathExpression_evaluate_WRONG_DOCUMENT_ERR.xml"/> |
| <suite.member href="XPathExpression_evaluate_NOT_SUPPORTED_ERR.xml"/> |
| <suite.member href="XPathNSResolver_lookupNamespaceURI_prefix.xml"/> |
| <suite.member href="XPathNSResolver_lookupNamespaceURI_nist_dmstc.xml"/> |
| <suite.member href="XPathNSResolver_lookupNamespaceURI_xml.xml"/> |
| <suite.member href="XPathNSResolver_lookupNamespaceURI_null.xml"/> |
| <suite.member href="XPathResult_booleanValue_true.xml"/> |
| <suite.member href="XPathResult_booleanValue_false.xml"/> |
| <suite.member href="XPathResult_iterateNext_INVALID_STATE_ERR.xml"/> |
| <suite.member href="XPathResult_invalidIteratorState_ANY_TYPE.xml"/> |
| <suite.member href="XPathResult_invalidIteratorState_ANY_UNORDERED_NODE_TYPE.xml"/> |
| <suite.member href="XPathResult_invalidIteratorState_BOOLEAN_TYPE.xml"/> |
| <suite.member href="XPathResult_invalidIteratorState_FIRST_ORDERED_NODE_TYPE.xml"/> |
| <suite.member href="XPathResult_invalidIteratorState_NUMBER_TYPE.xml"/> |
| <suite.member href="XPathResult_invalidIteratorState_ORDERED_NODE_ITERATOR_TYPE.xml"/> |
| <suite.member href="XPathResult_invalidIteratorState_ORDERED_NODE_SNAPSHOT_TYPE.xml"/> |
| <suite.member href="XPathResult_invalidIteratorState_STRING_TYPE.xml"/> |
| <suite.member href="XPathResult_invalidIteratorState_UNORDERED_NODE_ITERATOR_TYPE.xml"/> |
| <suite.member href="XPathResult_invalidIteratorState_UNORDERED_NODE_SNAPSHOT_TYPE.xml"/> |
| <suite.member href="XPathResult_iteratorNext_ORDERED_NODE_ITERATOR_TYPE.xml"/> |
| <suite.member href="XPathResult_numberValue.xml"/> |
| <suite.member href="XPathResult_resultType.xml"/> |
| <suite.member href="XPathResult_singleNodeValue_ANY_UNORDERED_NODE_TYPE.xml"/> |
| <suite.member href="XPathResult_singleNodeValue_FIRST_ORDERED_NODE_TYPE.xml"/> |
| <suite.member href="XPathResult_snapshotItem_ORDERED_NODE_SNAPSHOT_TYPE_null.xml"/> |
| <suite.member href="XPathResult_snapshotItem_ORDERED_NODE_SNAPSHOT_TYPE_order.xml"/> |
| <suite.member href="XPathResult_snapshotItem_UNORDERED_NODE_SNAPSHOT_TYPE_null.xml"/> |
| <suite.member href="XPathResult_snapshotItem_UNORDERED_NODE_SNAPSHOT_TYPE_count.xml"/> |
| <suite.member href="XPathResult_snapshotLength_ORDERED_NODE_SNAPSHOT_TYPE.xml"/> |
| <suite.member href="XPathResult_snapshotLength_UNORDERED_NODE_SNAPSHOT_TYPE.xml"/> |
| <suite.member href="XPathResult_stringValue.xml"/> |
| <suite.member href="XPathResult_TYPE_ERR.xml"/> |
| </suite> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/dom3xpathents.ent |
|---|
| 0,0 → 1,16 |
| <!ENTITY level3 "http://www.w3.org/2001/DOM-Test-Suite/Level-3"> |
| <!ENTITY spec "http://www.w3.org/TR/2003/CR-DOM-Level-3-XPath-20030331/xpath"> |
| <!ENTITY vars |
| " |
| <!-- common variables --> |
| <var name='doc' type='Document'/> |
| <var name='xpEvaluator' type='XPathEvaluator'/> |
| "> |
| <!-- the following entity requires the entity vars as well --> |
| <!ENTITY findXPathEvaluator |
| " |
| <load var='doc' href='staffNS' willBeModified='false'/> |
| <createXPathEvaluator var='xpEvaluator' document='doc'/> |
| "> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/CVS/Entries |
|---|
| 0,0 → 1,11 |
| /internaldtd.svg/1.2/Fri Apr 3 02:47:58 2009/-kb/ |
| /internaldtd.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /staff.dtd/1.1/Fri Apr 3 02:47:58 2009// |
| /staff.svg/1.1/Fri Apr 3 02:47:58 2009/-kb/ |
| /staff.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /staffNS.dtd/1.1/Fri Apr 3 02:47:58 2009// |
| /staffNS.svg/1.1/Fri Apr 3 02:47:58 2009/-kb/ |
| /staffNS.xml/1.1/Fri Apr 3 02:47:58 2009// |
| /svgtest.js/1.1/Fri Apr 3 02:47:58 2009/-kb/ |
| /svgunit.js/1.1/Fri Apr 3 02:47:58 2009/-kb/ |
| D |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/level3/xpath/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/CVS/Template |
|---|
| --- test/testcases/tests/level3/xpath/files/internaldtd.svg (nonexistent) |
| +++ test/testcases/tests/level3/xpath/files/internaldtd.svg (revision 4364) |
| @@ -0,0 +1,29 @@ |
| +<?xml version="1.0"?> |
| +<!DOCTYPE svg [ |
| + <!ELEMENT test (child)+ > |
| + <!ATTLIST test xmlns CDATA #IMPLIED> |
| + <!ELEMENT child EMPTY> |
| + <!ATTLIST child id ID #IMPLIED> |
| + <!ATTLIST child check CDATA #IMPLIED> |
| + <!ELEMENT svg (rect, script, test)> |
| + <!ATTLIST svg |
| + xmlns CDATA #FIXED "http://www.w3.org/2000/svg" |
| + name CDATA #IMPLIED> |
| + <!ELEMENT rect EMPTY> |
| + <!ATTLIST rect |
| + x CDATA #REQUIRED |
| + y CDATA #REQUIRED |
| + width CDATA #REQUIRED |
| + height CDATA #REQUIRED> |
| + <!ELEMENT script (#PCDATA)> |
| + <!ATTLIST script type CDATA #IMPLIED> |
| + <!ENTITY svgunit SYSTEM "svgunit.js"> |
| + <!ENTITY svgtest SYSTEM "svgtest.js"> |
| +]> |
| +<svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| +<test xmlns="http://www.example.org"> |
| + <child id="child1" check="child1"/> |
| + <child id="child2" check="child2"/> |
| +</test> |
| +</svg> |
| + |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/internaldtd.xml |
|---|
| 0,0 → 1,12 |
| <?xml version="1.0"?> |
| <!DOCTYPE test [ |
| <!ELEMENT test (child)+ > |
| <!ELEMENT child EMPTY> |
| <!ATTLIST child id ID #IMPLIED> |
| <!ATTLIST child check CDATA #IMPLIED> |
| ]> |
| <test> |
| <child id="child1" check="child1"/> |
| <child id="child2" check="child2"/> |
| </test> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/staff.dtd |
|---|
| 0,0 → 1,17 |
| <!ELEMENT employeeId (#PCDATA)> |
| <!ELEMENT name (#PCDATA)> |
| <!ELEMENT position (#PCDATA)> |
| <!ELEMENT salary (#PCDATA)> |
| <!ELEMENT address (#PCDATA)> |
| <!ELEMENT entElement ( #PCDATA ) > |
| <!ELEMENT gender ( #PCDATA | entElement )* > |
| <!ELEMENT employee (employeeId, name, position, salary, gender, address) > |
| <!ELEMENT staff (employee)+> |
| <!ATTLIST entElement |
| attr1 CDATA "Attr"> |
| <!ATTLIST address |
| domestic CDATA #IMPLIED |
| street CDATA "Yes"> |
| <!ATTLIST entElement |
| domestic CDATA "MALE" > |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/staff.svg |
|---|
| 0,0 → 1,72 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg SYSTEM "staff.dtd" [ |
| <!ENTITY ent1 "es"> |
| <!ENTITY ent2 "1900 Dallas Road"> |
| <!ENTITY ent3 "Texas"> |
| <!ENTITY ent4 "<entElement domestic='Yes'>Element data</entElement><?PItarget PIdata?>"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ENTITY ent1 "This entity should be discarded"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ATTLIST employee xmlns CDATA #IMPLIED> |
| <!ELEMENT svg (rect, script, employee+)> |
| <!ATTLIST svg |
| xmlns CDATA #FIXED "http://www.w3.org/2000/svg" |
| name CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <!-- This is comment number 1.--> |
| <svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds<![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Yes">&ent2; Dallas, &ent3; |
| 98554</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>&ent4;</gender> |
| <address domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0004</employeeId> |
| <name>Jeny Oconnor</name> |
| <position>Personnel Director</position> |
| <salary>95,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Y&ent1;">27 South Road. Dallas, Texas 98556</address> |
| </employee> |
| <employee xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-1/Files"> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/staff.xml |
|---|
| 0,0 → 1,57 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE staff SYSTEM "staff.dtd" [ |
| <!ENTITY ent1 "es"> |
| <!ENTITY ent2 "1900 Dallas Road"> |
| <!ENTITY ent3 "Texas"> |
| <!ENTITY ent4 "<entElement domestic='Yes'>Element data</entElement><?PItarget PIdata?>"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ENTITY ent1 "This entity should be discarded"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| ]> |
| <!-- This is comment number 1.--> |
| <staff> |
| <employee> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds<![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Yes">&ent2; Dallas, &ent3; |
| 98554</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>&ent4;</gender> |
| <address domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0004</employeeId> |
| <name>Jeny Oconnor</name> |
| <position>Personnel Director</position> |
| <salary>95,000</salary> |
| <gender>Female</gender> |
| <address domestic="Yes" street="Y&ent1;">27 South Road. Dallas, Texas 98556</address> |
| </employee> |
| <employee> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </staff> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/staffNS.dtd |
|---|
| 0,0 → 1,47 |
| <!ELEMENT staff (employee+,emp:employee,employee) > |
| <!ATTLIST staff xmlns CDATA #IMPLIED> |
| <!ATTLIST staff xmlns:nist CDATA #IMPLIED> |
| <!ELEMENT employee (employeeId,name,position,salary,gender,address) > |
| <!ATTLIST employee xmlns CDATA #IMPLIED> |
| <!ATTLIST employee xmlns:dmstc CDATA #IMPLIED> |
| <!ATTLIST employee xmlns:emp2 CDATA #IMPLIED> |
| <!ELEMENT employeeId (#PCDATA) > |
| <!ELEMENT name (#PCDATA) > |
| <!ELEMENT position (#PCDATA) > |
| <!ELEMENT salary (#PCDATA) > |
| <!ELEMENT entElement1 (#PCDATA) > |
| <!ELEMENT gender (#PCDATA | entElement1)* > |
| <!ATTLIST entElement1 xmlns:local1 CDATA #IMPLIED > |
| <!ELEMENT address (#PCDATA) > |
| <!ATTLIST address dmstc:domestic CDATA #IMPLIED> |
| <!ATTLIST address street CDATA #IMPLIED> |
| <!ATTLIST address domestic CDATA #IMPLIED> |
| <!ATTLIST address xmlns CDATA #IMPLIED> |
| <!ELEMENT emp:employee (emp:employeeId,nm:name,emp:position,emp:salary,emp:gender,emp:address) > |
| <!ATTLIST emp:employee xmlns:emp CDATA #IMPLIED> |
| <!ATTLIST emp:employee xmlns:nm CDATA #IMPLIED> |
| <!ATTLIST emp:employee defaultAttr CDATA 'defaultVal'> |
| <!ELEMENT emp:employeeId (#PCDATA) > |
| <!ELEMENT nm:name (#PCDATA) > |
| <!ELEMENT emp:position (#PCDATA) > |
| <!ELEMENT emp:salary (#PCDATA) > |
| <!ELEMENT emp:gender (#PCDATA) > |
| <!ELEMENT emp:address (#PCDATA) > |
| <!ATTLIST emp:address emp:domestic CDATA #IMPLIED> |
| <!ATTLIST emp:address street CDATA #IMPLIED> |
| <!ATTLIST emp:address emp:zone ID #IMPLIED> |
| <!ATTLIST emp:address emp:district CDATA 'DISTRICT'> |
| <!ATTLIST emp:address emp:local1 CDATA 'FALSE'> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/staffNS.svg |
|---|
| 0,0 → 1,73 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE svg PUBLIC "STAFF" "staffNS.dtd" |
| [ |
| <!ENTITY ent1 "es"> |
| <!ENTITY ent2 "1900 Dallas Road"> |
| <!ENTITY ent3 "Texas"> |
| <!ENTITY ent4 "<entElement1 xmlns:local1='www.xyz.com'>Element data</entElement1><?PItarget PIdata?>"> |
| <!ENTITY ent5 PUBLIC "entityURI" "entityFile" NDATA notation1> |
| <!ENTITY ent6 PUBLIC "uri" "file" NDATA notation2> |
| <!ENTITY ent1 "This entity should be discarded"> |
| <!NOTATION notation1 PUBLIC "notation1File"> |
| <!NOTATION notation2 SYSTEM "notation2File"> |
| <!ELEMENT svg (rect, script, employee+, emp:employee, employee*)> |
| <!ATTLIST svg |
| xmlns CDATA #FIXED "http://www.w3.org/2000/svg" |
| name CDATA #IMPLIED> |
| <!ELEMENT rect EMPTY> |
| <!ATTLIST rect |
| x CDATA #REQUIRED |
| y CDATA #REQUIRED |
| width CDATA #REQUIRED |
| height CDATA #REQUIRED> |
| <!ELEMENT script (#PCDATA)> |
| <!ATTLIST script type CDATA #IMPLIED> |
| <!ENTITY svgunit SYSTEM "svgunit.js"> |
| <!ENTITY svgtest SYSTEM "svgtest.js"> |
| ]> |
| <!-- This is comment number 1.--> |
| <svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="100" height="100"/><script type="text/ecmascript">&svgtest;&svgunit;</script> |
| <employee xmlns="http://www.nist.gov" xmlns:dmstc="http://www.usa.com"> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address dmstc:domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee xmlns:dmstc="http://www.usa.com" xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2/Files"> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds |
| <![CDATA[This is a CDATASection with EntityReference number 2 &ent2;]]> |
| <![CDATA[This is an adjacent CDATASection with a reference to a tab &tab;]]></name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address dmstc:domestic="Yes" street="Yes">&ent2; Dallas, &ent3; |
| 98554</address> |
| </employee> |
| <employee xmlns:dmstc="http://www.netzero.com" xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2/Files"> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>&ent4;</gender> |
| <address dmstc:domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <emp:employee xmlns:emp="http://www.nist.gov" xmlns:nm="http://www.altavista.com" > <emp:employeeId>EMP0004</emp:employeeId> |
| <nm:name>Jeny Oconnor</nm:name> |
| <emp:position>Personnel Director</emp:position> |
| <emp:salary>95,000</emp:salary> |
| <emp:gender>Female</emp:gender> |
| <emp:address emp:domestic="Yes" street="Y&ent1;" emp:zone="CANADA" emp:local1="TRUE">27 South Road. Dallas, texas 98556</emp:address> |
| </emp:employee> |
| <employee xmlns:emp2="http://www.nist.gov" xmlns="http://www.w3.org/2001/DOM-Test-Suite/Level-2/Files"> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes" xmlns="http://www.nist.gov">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </svg> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/files/staffNS.xml |
|---|
| 0,0 → 1,44 |
| <?xml version="1.0"?><?TEST-STYLE PIDATA?> |
| <!DOCTYPE staff PUBLIC "STAFF" "staffNS.dtd"> |
| <staff xmlns="http://www.nist.gov" xmlns:nist="http://www.nist.gov"> |
| <employee xmlns:dmstc="http://www.usa.com"> |
| <employeeId>EMP0001</employeeId> |
| <name>Margaret Martin</name> |
| <position>Accountant</position> |
| <salary>56,000</salary> |
| <gender>Female</gender> |
| <address dmstc:domestic="Yes">1230 North Ave. Dallas, Texas 98551</address> |
| </employee> |
| <employee xmlns:dmstc="http://www.usa.com"> |
| <employeeId>EMP0002</employeeId> |
| <name>Martha Raynolds</name> |
| <position>Secretary</position> |
| <salary>35,000</salary> |
| <gender>Female</gender> |
| <address dmstc:domestic="Yes" street="Yes">1900 Dallas Road Dallas, Texas 98554</address> |
| </employee> |
| <employee xmlns:dmstc="http://www.netzero.com"> |
| <employeeId>EMP0003</employeeId> |
| <name>Roger |
| Jones</name> |
| <position>Department Manager</position> |
| <salary>100,000</salary> |
| <gender>Male</gender> |
| <address dmstc:domestic="Yes" street="No">PO Box 27 Irving, texas 98553</address> |
| </employee> |
| <emp:employee xmlns:emp="http://www.nist.gov" xmlns:nm="http://www.altavista.com" > <emp:employeeId>EMP0004</emp:employeeId> |
| <nm:name>Jeny Oconnor</nm:name> |
| <emp:position>Personnel Director</emp:position> |
| <emp:salary>95,000</emp:salary> |
| <emp:gender>Female</emp:gender> |
| <emp:address emp:domestic="Yes" street="Yes" emp:zone="CANADA" emp:local1="TRUE">27 South Road. Dallas, texas 98556</emp:address> |
| </emp:employee> |
| <employee xmlns:emp2="http://www.nist.gov"> |
| <employeeId>EMP0005</employeeId> |
| <name>Robert Myers</name> |
| <position>Computer Specialist</position> |
| <salary>90,000</salary> |
| <gender>male</gender> |
| <address street="Yes" xmlns="http://www.nist.gov">1821 Nordic. Road, Irving Texas 98558</address> |
| </employee> |
| </staff> |
| /contrib/network/netsurf/libdom/test/testcases/tests/level3/xpath/metadata.xml |
|---|
| 0,0 → 1,19 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| Copyright (c) 2003 World Wide Web Consortium, |
| (Massachusetts Institute of Technology, European Research Consortium for |
| Informatics and Mathematics, Keio University). All Rights Reserved. This |
| work is distributed under the W3C(r) Software License [1] in the hope that |
| it will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| --> |
| <!DOCTYPE metadata SYSTEM 'dom3.dtd' [ |
| <!ENTITY % entities SYSTEM "dom3xpathents.ent"> |
| %entities; |
| ]> |
| <metadata xmlns="&level3;"> |
| </metadata> |
| /contrib/network/netsurf/libdom/test/testcases/tests/submittedtests/CVS/Entries |
|---|
| 0,0 → 1,0 |
| D/netscapeHTML//// |
| /contrib/network/netsurf/libdom/test/testcases/tests/submittedtests/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/submittedtests |
| /contrib/network/netsurf/libdom/test/testcases/tests/submittedtests/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/submittedtests/CVS/Template |
|---|
| --- test/testcases/tests/submittedtests/netscapeHTML/CVS/Entries (nonexistent) |
| +++ test/testcases/tests/submittedtests/netscapeHTML/CVS/Entries (revision 4364) |
| @@ -0,0 +1 @@ |
| +D |
| /contrib/network/netsurf/libdom/test/testcases/tests/submittedtests/netscapeHTML/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/submittedtests/netscapeHTML |
| /contrib/network/netsurf/libdom/test/testcases/tests/submittedtests/netscapeHTML/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/submittedtests/netscapeHTML/CVS/Template |
|---|
| --- test/testcases/tests/validation/CVS/Entries (nonexistent) |
| +++ test/testcases/tests/validation/CVS/Entries (revision 4364) |
| @@ -0,0 +1 @@ |
| +D/files//// |
| /contrib/network/netsurf/libdom/test/testcases/tests/validation/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/validation |
| /contrib/network/netsurf/libdom/test/testcases/tests/validation/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/validation/CVS/Template |
|---|
| --- test/testcases/tests/validation/files/CVS/Entries (nonexistent) |
| +++ test/testcases/tests/validation/files/CVS/Entries (revision 4364) |
| @@ -0,0 +1 @@ |
| +D |
| /contrib/network/netsurf/libdom/test/testcases/tests/validation/files/CVS/Repository |
|---|
| 0,0 → 1,0 |
| 2001/DOM-Test-Suite/tests/validation/files |
| /contrib/network/netsurf/libdom/test/testcases/tests/validation/files/CVS/Root |
|---|
| 0,0 → 1,0 |
| :pserver:anonymous@dev.w3.org:/sources/public |
| /contrib/network/netsurf/libdom/test/testcases/tests/validation/files/CVS/Template |
|---|
| --- test/testutils/comparators.c (nonexistent) |
| +++ test/testutils/comparators.c (revision 4364) |
| @@ -0,0 +1,80 @@ |
| +/* |
| + * This file is part of libdom test suite. |
| + * Licensed under the MIT License, |
| + * http://www.opensource.org/licenses/mit-license.php |
| + * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| + */ |
| + |
| +#include "comparators.h" |
| +#include "domts.h" |
| + |
| +#include <string.h> |
| + |
| +#include <dom/dom.h> |
| + |
| +/* Compare to integer, return zero if equal */ |
| +int int_comparator(const void* a, const void* b) { |
| + return *((const int *)a) - *((const int *)b); |
| +} |
| + |
| +/* Compare two string. The first one is a char * and the second |
| + * one is a dom_string, return zero if equal */ |
| +int str_cmp(const void *a, const void *b) |
| +{ |
| + const uint8_t *expected = (const uint8_t *) a; |
| + dom_string *actual = (dom_string *) b; |
| + dom_string *exp; |
| + dom_exception err; |
| + bool ret; |
| + |
| + err = dom_string_create(expected, strlen((const char *)expected), |
| + &exp); |
| + if (err != DOM_NO_ERR) |
| + return false; |
| + |
| + ret = dom_string_isequal(exp, actual); |
| + |
| + dom_string_unref(exp); |
| + |
| + if (ret == true) |
| + return 0; |
| + else |
| + return 1; |
| +} |
| + |
| +/* Similar with str_cmp but the first param is a dom_string the second |
| + * param is a char * */ |
| +int str_cmp_r(const void *a, const void *b) |
| +{ |
| + return str_cmp(b, a); |
| +} |
| + |
| +/* Similar with str_cmp but ignore the case of letters */ |
| +int str_icmp(const void *a, const void *b) |
| +{ |
| + const uint8_t *expected = (const uint8_t *) a; |
| + dom_string *actual = (dom_string *) b; |
| + dom_string *exp; |
| + dom_exception err; |
| + bool ret; |
| + |
| + err = dom_string_create(expected, strlen((const char *)expected), |
| + &exp); |
| + if (err != DOM_NO_ERR) |
| + return false; |
| + |
| + ret = dom_string_caseless_isequal(exp, actual); |
| + |
| + dom_string_unref(exp); |
| + |
| + if (ret == true) |
| + return 0; |
| + else |
| + return 1; |
| +} |
| + |
| +/* Similar with str_icmp, but the param order are reverse */ |
| +int str_icmp_r(const void *a, const void *b) |
| +{ |
| + return str_icmp(b, a); |
| +} |
| /contrib/network/netsurf/libdom/test/testutils/comparators.h |
|---|
| 0,0 → 1,23 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 James Shaw <jshaw@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef comparators_h_ |
| #define comparators_h_ |
| /** |
| * A function pointer type for a comparator. |
| */ |
| typedef int (*comparator)(const void* a, const void* b); |
| int int_comparator(const void* a, const void* b); |
| int str_icmp(const void *a, const void *b); |
| int str_icmp_r(const void *a, const void *b); |
| int str_cmp(const void *a, const void *b); |
| int str_cmp_r(const void *a, const void *b); |
| #endif |
| /contrib/network/netsurf/libdom/test/testutils/domts.h |
|---|
| 0,0 → 1,21 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef domts_h_ |
| #define domts_h_ |
| #include <domtscondition.h> |
| #include <domtsasserts.h> |
| #include <list.h> |
| #include <foreach.h> |
| #include <utils.h> |
| #include <comparators.h> |
| dom_document *load_xml(const char *file, bool willBeModified); |
| dom_document *load_html(const char *file, bool willBeModified); |
| #endif |
| /contrib/network/netsurf/libdom/test/testutils/domtsasserts.c |
|---|
| 0,0 → 1,376 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdio.h> |
| #include <stdbool.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <dom/dom.h> |
| #include "domts.h" |
| void __assert2(const char *expr, const char *function, |
| const char *file, int line) |
| { |
| UNUSED(function); |
| UNUSED(file); |
| printf("FAIL - %s at line %d\n", expr, line); |
| exit(EXIT_FAILURE); |
| } |
| /** |
| * Following are the test conditions which defined in the DOMTS, please refer |
| * the DOM Test Suite for details |
| */ |
| bool is_true(bool arg) |
| { |
| return arg == true; |
| } |
| bool is_null(void *arg) |
| { |
| return arg == NULL; |
| } |
| bool is_same(void *expected, void *actual) |
| { |
| return expected == actual; |
| } |
| bool is_same_int(int expected, int actual) |
| { |
| return expected == actual; |
| } |
| bool is_same_unsigned_int32_t(uint32_t expected, uint32_t actual) |
| { |
| return expected == actual; |
| } |
| bool is_equals_int(int expected, int actual, bool dummy) |
| { |
| UNUSED(dummy); |
| return expected == actual; |
| } |
| bool is_equals_bool(bool expected, bool actual, bool dummy) |
| { |
| UNUSED(dummy); |
| return expected == actual; |
| } |
| bool is_equals_unsigned_int32_t(uint32_t expected, uint32_t actual, bool dummy) |
| { |
| UNUSED(dummy); |
| return expected == actual; |
| } |
| /** |
| * Test whether two string are equal |
| * |
| * \param expected The expected string |
| * \param actual The actual string |
| * \param ignoreCase Whether to ignore letter case |
| */ |
| bool is_equals_string(const char *expected, dom_string *actual, |
| bool ignoreCase) |
| { |
| dom_string *exp; |
| dom_exception err; |
| bool ret; |
| err = dom_string_create((const uint8_t *)expected, strlen(expected), |
| &exp); |
| if (err != DOM_NO_ERR) |
| return false; |
| if (ignoreCase == true) |
| ret = dom_string_caseless_isequal(exp, actual); |
| else |
| ret = dom_string_isequal(exp, actual); |
| dom_string_unref(exp); |
| return ret; |
| } |
| /* Compare whether two dom_string are equal */ |
| bool is_equals_domstring(dom_string *expected, dom_string *actual, |
| bool ignoreCase) |
| { |
| if (ignoreCase == true) |
| return dom_string_caseless_isequal(expected, actual); |
| else |
| return dom_string_isequal(expected, actual); |
| } |
| /* The param actual should always contain dom_sting and expectd should |
| * contain char * */ |
| bool is_equals_list(list *expected, list *actual, bool ignoreCase) |
| { |
| assert((expected->type && 0xff00) == (actual->type && 0xff00)); |
| comparator cmp = NULL; |
| comparator rcmp = NULL; |
| if (expected->type == INT) |
| cmp = int_comparator; |
| if (expected->type == STRING) { |
| if (actual->type == DOM_STRING) { |
| cmp = ignoreCase? str_icmp : str_cmp; |
| rcmp = ignoreCase? str_icmp_r : str_cmp_r; |
| } |
| } |
| if (expected->type == DOM_STRING) { |
| if (actual->type == STRING) { |
| cmp = ignoreCase? str_icmp_r : str_cmp_r; |
| rcmp = ignoreCase? str_icmp : str_cmp; |
| } |
| } |
| assert(cmp != NULL); |
| return list_contains_all(expected, actual, cmp) && list_contains_all(actual, expected, rcmp); |
| } |
| bool is_instanceof(const char *type, dom_node *node) |
| { |
| assert("There is no instanceOf in the test-suite" == NULL); |
| (void)type; |
| (void)node; |
| return false; |
| } |
| bool is_size_domnamednodemap(uint32_t size, dom_namednodemap *map) |
| { |
| uint32_t len; |
| dom_exception err; |
| err = dom_namednodemap_get_length(map, &len); |
| if (err != DOM_NO_ERR) { |
| assert("Exception occured" == NULL); |
| return false; |
| } |
| return size == len; |
| } |
| bool is_size_domnodelist(uint32_t size, dom_nodelist *list) |
| { |
| uint32_t len; |
| dom_exception err; |
| err = dom_nodelist_get_length(list, &len); |
| if (err != DOM_NO_ERR) { |
| assert("Exception occured" == NULL); |
| return false; |
| } |
| return size == len; |
| } |
| bool is_size_list(uint32_t size, list *list) |
| { |
| return size == list->size; |
| } |
| bool is_uri_equals(const char *scheme, const char *path, const char *host, |
| const char *file, const char *name, const char *query, |
| const char *fragment, const char *isAbsolute, |
| dom_string *actual) |
| { |
| const char *_ptr = actual != NULL ? dom_string_data(actual) : NULL; |
| const size_t slen = actual != NULL ? dom_string_byte_length(actual) : 0; |
| char *_sptr = actual != NULL ? domts_strndup(_ptr, slen) : NULL; |
| char *sptr = _sptr; |
| bool result = false; |
| /* Used farther down */ |
| const char *firstColon = NULL; |
| const char *firstSlash = NULL; |
| char *actualPath = NULL; |
| char *actualScheme = NULL; |
| char *actualHost = NULL; |
| char *actualFile = NULL; |
| char *actualName = NULL; |
| assert(sptr != NULL); |
| /* Note, from here on down, this is essentially a semi-direct |
| * reimplementation of assertURIEquals in the Java DOMTS. |
| */ |
| /* Attempt to check fragment */ |
| { |
| char *fptr = strrchr(sptr, '#'); |
| const char *cfptr = fptr + 1; |
| if (fptr != NULL) { |
| *fptr = '\0'; /* Remove fragment from sptr */ |
| } else { |
| cfptr = ""; |
| } |
| if (fragment != NULL) { |
| if (strcmp(fragment, cfptr) != 0) |
| goto out; |
| } |
| } |
| /* Attempt to check query string */ |
| { |
| char *qptr = strrchr(sptr, '?'); |
| const char *cqptr = qptr + 1; |
| if (qptr != NULL) { |
| *qptr = '\0'; /* Remove query from sptr */ |
| } else { |
| cqptr = ""; |
| } |
| if (query != NULL) { |
| if (strcmp(query, cqptr) != 0) |
| goto out; |
| } |
| } |
| /* Scheme and path */ |
| firstColon = strchr(sptr, ':'); |
| firstSlash = strchr(sptr, '/'); |
| actualPath = strdup(sptr); |
| actualScheme = strdup(""); |
| if (firstColon != NULL && firstColon < firstSlash) { |
| free(actualScheme); |
| free(actualPath); |
| actualScheme = domts_strndup(sptr, firstColon - sptr); |
| actualPath = strdup(firstColon + 1); |
| } |
| if (scheme != NULL) { |
| if (strcmp(scheme, actualScheme) != 0) |
| goto out; |
| } |
| if (path != NULL) { |
| if (strcmp(path, actualPath) != 0) |
| goto out; |
| } |
| /* host */ |
| if (host != NULL) { |
| if (actualPath[0] == '/' && |
| actualPath[1] == '/') { |
| const char *termslash = strchr(actualPath + 2, '/'); |
| actualHost = domts_strndup(actualPath, |
| termslash - actualPath); |
| } else { |
| actualHost = strdup(""); |
| } |
| if (strcmp(actualHost, host) != 0) |
| goto out; |
| } |
| /* file */ |
| actualFile = strdup(actualPath); |
| if (file != NULL || name != NULL) { |
| const char *finalSlash = strrchr(actualPath, '/'); |
| if (finalSlash != NULL) { |
| free(actualFile); |
| actualFile = strdup(finalSlash + 1); |
| } |
| if (file != NULL) { |
| if (strcmp(actualFile, file) != 0) |
| goto out; |
| } |
| } |
| /* name */ |
| if (name != NULL) { |
| const char *finalPeriod = strrchr(actualFile, '.'); |
| if (finalPeriod != NULL) { |
| actualName = domts_strndup(actualFile, |
| finalPeriod - actualFile); |
| } else { |
| actualName = strdup(actualFile); |
| } |
| if (strcmp(actualName, name) != 0) |
| goto out; |
| } |
| /* isAbsolute */ |
| if (isAbsolute != NULL) { |
| bool startslash = *actualPath == '/'; |
| bool isabsolute = strcasecmp(isAbsolute, "true") == 0; |
| isabsolute |= (strcasecmp(isAbsolute, "yes") == 0); |
| isabsolute |= (strcmp(isAbsolute, "1") == 0); |
| startslash |= (strncmp(actualPath, "file:/", 6) == 0); |
| if (isabsolute != startslash) |
| goto out; |
| } |
| result = true; |
| out: |
| if (actualPath != NULL) |
| free(actualPath); |
| if (actualScheme != NULL) |
| free(actualScheme); |
| if (actualHost != NULL) |
| free(actualHost); |
| if (actualFile != NULL) |
| free(actualFile); |
| if (actualName != NULL) |
| free(actualName); |
| free(_sptr); |
| return result; |
| } |
| bool is_contenttype(const char *type) |
| { |
| /* Now, we use the libxml2 parser for DOM parsing, so the content type |
| * is always "text/xml" */ |
| if (strcmp(type, "text/xml") == 0) |
| return true; |
| else |
| return false; |
| } |
| bool has_feature(const char *feature, const char *version) |
| { |
| dom_exception err; |
| bool ret; |
| if (feature == NULL) |
| feature = ""; |
| if (version == NULL) |
| version = ""; |
| err = dom_implementation_has_feature(feature, version, &ret); |
| /* Here, when we come with exception, we should return false, |
| * TODO: this need to be improved, but I can't figure out how */ |
| if (err != DOM_NO_ERR) { |
| return false; |
| } |
| return ret; |
| } |
| bool implementation_attribute(char *name, bool value) |
| { |
| /* We didnot support DOMConfigure for implementation now */ |
| UNUSED(name); |
| UNUSED(value); |
| return true; |
| } |
| /contrib/network/netsurf/libdom/test/testutils/domtsasserts.h |
|---|
| 0,0 → 1,63 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef domtsasserts_h_ |
| #define domtsasserts_h_ |
| #include <stdbool.h> |
| #include <dom/dom.h> |
| #include "list.h" |
| /* Redefine assert, so we can simply use the standard assert mechanism |
| * within testcases and exit with the right output for the testrunner |
| * to do the right thing. */ |
| void __assert2(const char *expr, const char *function, |
| const char *file, int line); |
| #define assert(expr) \ |
| ((void) ((expr) || (__assert2 (#expr, __func__, __FILE__, __LINE__), 0))) |
| bool is_true(bool arg); |
| bool is_null(void *arg); |
| bool is_same(void *excepted, void *actual); |
| bool is_same_int(int excepted, int actual); |
| bool is_same_unsigned_int32_t(uint32_t excepted, uint32_t actual); |
| bool is_equals_int(int excepted, int actual, bool dummy); |
| bool is_equals_unsigned_int32_t(uint32_t excepted, uint32_t actual, bool dummy); |
| bool is_equals_bool(bool excepted, bool actual, bool dummy); |
| bool is_equals_string(const char *excepted, dom_string *actual, |
| bool ignoreCase); |
| bool is_equals_domstring(dom_string *excepted, dom_string *actual, bool ignoreCase); |
| /* We may use two different string types in libDOM, but the expected string type is |
| always "char *" */ |
| bool is_equals_list(list *expected, list *actual, bool ignoreCase); |
| bool is_instanceof(const char *type, dom_node *node); |
| bool is_size_domnamednodemap(uint32_t size, dom_namednodemap *map); |
| bool is_size_domnodelist(uint32_t size, dom_nodelist *list); |
| bool is_size_list(uint32_t size, list *list); |
| bool is_uri_equals(const char *scheme, const char *path, const char *host, |
| const char *file, const char *name, const char *query, |
| const char *fragment, const char *isAbsolute, |
| dom_string *actual); |
| bool is_contenttype(const char *type); |
| bool has_feature(const char *feature, const char *version); |
| bool implementation_attribute(char *name, bool value); |
| #endif |
| /contrib/network/netsurf/libdom/test/testutils/domtscondition.h |
|---|
| 0,0 → 1,37 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef domtscondition_h_ |
| #define domtscondition_h_ |
| #include <stdbool.h> |
| /** |
| * Just simple functions which meet the needs of DOMTS conditions |
| */ |
| static inline bool less(int excepted, int actual) |
| { |
| return actual < excepted; |
| } |
| static inline bool less_or_equals(int excepted, int actual) |
| { |
| return actual <= excepted; |
| } |
| static inline bool greater(int excepted, int actual) |
| { |
| return actual > excepted; |
| } |
| static inline bool greater_or_equals(int excepted, int actual) |
| { |
| return actual >= excepted; |
| } |
| #endif |
| /contrib/network/netsurf/libdom/test/testutils/foreach.c |
|---|
| 0,0 → 1,125 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdbool.h> |
| #include "foreach.h" |
| #include "list.h" |
| #include <dom/dom.h> |
| /** |
| * Please see foreach.h for the usage of the following functions |
| */ |
| void foreach_initialise_domnodelist(dom_nodelist *list, unsigned int *iterator) |
| { |
| (void)list; |
| *iterator = 0; |
| } |
| void foreach_initialise_list(list *list, unsigned int *iterator) |
| { |
| (void)list; |
| *iterator = 0; |
| } |
| void foreach_initialise_domnamednodemap(dom_namednodemap *map, unsigned int *iterator) |
| { |
| (void)map; |
| *iterator = 0; |
| } |
| void foreach_initialise_domhtmlcollection(dom_html_collection *coll, unsigned int *iterator) |
| { |
| (void)coll; |
| *iterator = 0; |
| } |
| bool _get_next_domnodelist(dom_nodelist *list, unsigned int *iterator, dom_node **ret) |
| { |
| dom_exception err; |
| uint32_t len; |
| err = dom_nodelist_get_length(list, &len); |
| if (err != DOM_NO_ERR) |
| return false; |
| if (*iterator >= len) |
| return false; |
| err = dom_nodelist_item(list, (*iterator), ret); |
| if (err != DOM_NO_ERR) |
| return false; |
| (*iterator)++; |
| return true; |
| } |
| bool get_next_list(list *list, unsigned int *iterator, void **ret) |
| { |
| unsigned int len = *iterator; |
| unsigned int i = 0; |
| struct list_elt *elt = list->head; |
| for (; i < len; i++) { |
| if (elt == NULL) |
| return false; |
| elt = elt->next; |
| } |
| if (elt == NULL) |
| return false; |
| *ret = elt->data; |
| (*iterator)++; |
| return true; |
| } |
| bool _get_next_domnamednodemap(dom_namednodemap *map, unsigned int *iterator, dom_node **ret) |
| { |
| dom_exception err; |
| uint32_t len; |
| err = dom_namednodemap_get_length(map, &len); |
| if (err != DOM_NO_ERR) |
| return false; |
| if (*iterator >= len) |
| return false; |
| err = dom_namednodemap_item(map, (*iterator), ret); |
| if (err != DOM_NO_ERR) |
| return false; |
| (*iterator)++; |
| return true; |
| } |
| bool _get_next_domhtmlcollection(dom_html_collection *coll, unsigned int *iterator, dom_node **ret) |
| { |
| dom_exception err; |
| uint32_t len; |
| err = dom_html_collection_get_length(coll, &len); |
| if (err != DOM_NO_ERR) |
| return false; |
| if (*iterator >= len) |
| return false; |
| err = dom_html_collection_item(coll, (*iterator), ret); |
| if (err != DOM_NO_ERR) |
| return false; |
| (*iterator)++; |
| return true; |
| } |
| /contrib/network/netsurf/libdom/test/testutils/foreach.h |
|---|
| 0,0 → 1,45 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #ifndef domts_foreach_h_ |
| #define domts_foreach_h_ |
| #include <dom/dom.h> |
| #include <list.h> |
| /* The following six functions are used for the XML testcase's |
| <for-each> element. |
| And the <for-each> element can be converted to : |
| unsigned int iterator; |
| foreach_initialise_*(list, &iterator); |
| while(get_next_*(list, &iterator, ret)){ |
| do the loop work. |
| } |
| */ |
| void foreach_initialise_domnodelist(dom_nodelist *list, unsigned int *iterator); |
| void foreach_initialise_list(list *list, unsigned int *iterator); |
| void foreach_initialise_domnamednodemap(dom_namednodemap *map, unsigned int *iterator); |
| void foreach_initialise_domhtmlcollection(dom_html_collection *coll, unsigned int *iterator); |
| bool _get_next_domnodelist(dom_nodelist *list, unsigned int *iterator, dom_node **ret); |
| #define get_next_domnodelist(l, i, r) _get_next_domnodelist( \ |
| (dom_nodelist *) (l), (unsigned int *) (i), (dom_node **) (r)) |
| bool get_next_list(list *list, unsigned int *iterator, void **ret); |
| bool _get_next_domnamednodemap(dom_namednodemap *map, unsigned int *iterator, dom_node **ret); |
| #define get_next_domnamednodemap(m, i, r) _get_next_domnamednodemap( \ |
| (dom_namednodemap *) (m), (unsigned int *) (i), (dom_node **) (r)) |
| bool _get_next_domhtmlcollection(dom_html_collection *coll, unsigned int *iterator, dom_node **ret); |
| #define get_next_domhtmlcollection(c, i, r) _get_next_domhtmlcollection( \ |
| (dom_html_collection *) (c), (unsigned int *) (i), (dom_node **) (r)) |
| #endif |
| /contrib/network/netsurf/libdom/test/testutils/list.c |
|---|
| 0,0 → 1,171 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 James Shaw <jshaw@netsurf-browser.org> |
| * Copyright 2009 Bo Yang <struggeleyb.nku@gmail.com> |
| */ |
| #include <stdbool.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <dom/core/string.h> |
| #include <dom/core/node.h> |
| #include "comparators.h" |
| #include "list.h" |
| #include "domtsasserts.h" |
| /** |
| * Private helper function. |
| * Create a new list_elt and initialise it. |
| */ |
| struct list_elt* list_new_elt(void* data); |
| struct list_elt* list_new_elt(void* data) { |
| struct list_elt* elt = malloc(sizeof(struct list_elt)); |
| assert(elt != NULL); |
| elt->data = data; |
| elt->next = NULL; |
| return elt; |
| } |
| struct list* list_new(TYPE type) |
| { |
| struct list* list = malloc(sizeof(struct list)); |
| assert(list != NULL); |
| list->size = 0; |
| list->type = type; |
| list->head = NULL; |
| list->tail = NULL; |
| return list; |
| } |
| void list_destroy(struct list* list) |
| { |
| struct list_elt* elt = list->head; |
| while (elt != NULL) { |
| if (list->type == DOM_STRING) |
| dom_string_unref((dom_string *) elt->data); |
| if (list->type == NODE) |
| dom_node_unref(elt->data); |
| struct list_elt* nextElt = elt->next; |
| free(elt); |
| elt = nextElt; |
| } |
| free(list); |
| } |
| void list_add(struct list* list, void* data) |
| { |
| struct list_elt* elt = list_new_elt(data); |
| struct list_elt* tail = list->tail; |
| /* if tail was set, make its 'next' ptr point to elt */ |
| if (tail != NULL) { |
| tail->next = elt; |
| } |
| /* make elt the new tail */ |
| list->tail = elt; |
| if (list->head == NULL) { |
| list->head = elt; |
| } |
| /* inc the size of the list */ |
| list->size++; |
| if (list->type == DOM_STRING) |
| dom_string_ref((dom_string *) data); |
| if (list->type == NODE) |
| dom_node_ref(data); |
| } |
| bool list_remove(struct list* list, void* data) |
| { |
| struct list_elt* prevElt = NULL; |
| struct list_elt* elt = list->head; |
| bool found = false; |
| while (elt != NULL) { |
| struct list_elt* nextElt = elt->next; |
| /* if data is identical, fix up pointers, and free the element */ |
| if (data == elt->data) { |
| if (prevElt == NULL) { |
| list->head = nextElt; |
| } else { |
| prevElt->next = nextElt; |
| } |
| free(elt); |
| list->size--; |
| found = true; |
| break; |
| } |
| prevElt = elt; |
| elt = nextElt; |
| } |
| return found; |
| } |
| struct list* list_clone(struct list* list) |
| { |
| struct list* newList = list_new(list->type); |
| struct list_elt* elt = list->head; |
| while (elt != NULL) { |
| list_add(newList, elt->data); |
| elt = elt->next; |
| } |
| return newList; |
| } |
| bool list_contains(struct list* list, void* data, comparator comparator) |
| { |
| struct list_elt* elt = list->head; |
| while (elt != NULL) { |
| if (comparator(elt->data, data) == 0) { |
| return true; |
| } |
| elt = elt->next; |
| } |
| return false; |
| } |
| bool list_contains_all(struct list* superList, struct list* subList, |
| comparator comparator) |
| { |
| struct list_elt* subElt = subList->head; |
| struct list* superListClone = list_clone(superList); |
| bool found = true; |
| while (subElt != NULL) { |
| struct list_elt* superElt = superListClone->head; |
| found = false; |
| while (superElt != NULL && found == false) { |
| if (comparator(superElt->data, subElt->data) == 0) { |
| found = true; |
| list_remove(superListClone, superElt->data); |
| break; |
| } |
| superElt = superElt->next; |
| } |
| if (found == false) |
| break; |
| subElt = subElt->next; |
| } |
| free(superListClone); |
| return found; |
| } |
| /contrib/network/netsurf/libdom/test/testutils/list.h |
|---|
| 0,0 → 1,70 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 James Shaw <jshaw@netsurf-browser.org> |
| */ |
| #ifndef list_h_ |
| #define list_h_ |
| #include <stdbool.h> |
| #include "comparators.h" |
| /* The element type in the list |
| * |
| * The high byte is used for category type |
| * The low byte is used for concrete type |
| */ |
| typedef enum TYPE { |
| INT = 0x0001, |
| STRING = 0x0100, |
| DOM_STRING = 0x0101, |
| NODE = 0x0200 |
| } TYPE; |
| struct list_elt { |
| void* data; |
| struct list_elt* next; |
| }; |
| typedef struct list { |
| unsigned int size; |
| TYPE type; |
| struct list_elt* head; |
| struct list_elt* tail; |
| } list; |
| struct list* list_new(TYPE type); |
| void list_destroy(struct list* list); |
| /** |
| * Add data to the tail of the list. |
| */ |
| void list_add(struct list* list, void* data); |
| /** |
| * Remove element containing data from list. |
| * The list element is freed, but the caller must free the data itself |
| * if necessary. |
| * |
| * Returns true if data was found in the list. |
| */ |
| bool list_remove(struct list* list, void* data); |
| struct list* list_clone(struct list* list); |
| /** |
| * Tests if data is equal to any element in the list. |
| */ |
| bool list_contains(struct list* list, void* data, |
| comparator comparator); |
| /** |
| * Tests if superlist contains all elements in sublist. Order is not important. |
| */ |
| bool list_contains_all(struct list* superList, struct list* subList, |
| comparator comparator); |
| #endif |
| /contrib/network/netsurf/libdom/test/testutils/load.c |
|---|
| 0,0 → 1,159 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> |
| */ |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <sys/types.h> |
| #include <sys/uio.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <libwapcaplet/libwapcaplet.h> |
| // For parsers |
| #include <dom/dom.h> |
| #include <xmlparser.h> |
| #include <parser.h> |
| #include <errors.h> |
| #include "utils.h" |
| #include "domts.h" |
| /** |
| * Load the file as it is a XML file |
| * |
| * \param file The file path |
| * \param willBeModified Whether this file will be modified, not used |
| */ |
| dom_document *load_xml(const char *file, bool willBeModified) |
| { |
| dom_xml_parser *parser = NULL; |
| int handle; |
| int readed; |
| dom_xml_error error; |
| dom_document *ret; |
| uint8_t buffer[1024]; |
| UNUSED(willBeModified); |
| parser = dom_xml_parser_create(NULL, NULL, mymsg, NULL, &ret); |
| if (parser == NULL) { |
| fprintf(stderr, "Can't create XMLParser\n"); |
| return NULL; |
| } |
| handle = open(file, O_RDONLY); |
| if (handle == -1) { |
| dom_node_unref(ret); |
| dom_xml_parser_destroy(parser); |
| fprintf(stderr, "Can't open test input file: %s\n", file); |
| return NULL; |
| } |
| readed = read(handle, buffer, 1024); |
| error = dom_xml_parser_parse_chunk(parser, buffer, readed); |
| if (error != DOM_XML_OK) { |
| dom_node_unref(ret); |
| dom_xml_parser_destroy(parser); |
| fprintf(stderr, "Parsing errors occur\n"); |
| return NULL; |
| } |
| while(readed == 1024) { |
| readed = read(handle, buffer, 1024); |
| error = dom_xml_parser_parse_chunk(parser, buffer, readed); |
| if (error != DOM_XML_OK) { |
| dom_node_unref(ret); |
| dom_xml_parser_destroy(parser); |
| fprintf(stderr, "Parsing errors occur\n"); |
| return NULL; |
| } |
| } |
| error = dom_xml_parser_completed(parser); |
| if (error != DOM_XML_OK) { |
| dom_node_unref(ret); |
| dom_xml_parser_destroy(parser); |
| fprintf(stderr, "Parsing error when construct DOM\n"); |
| return NULL; |
| } |
| dom_xml_parser_destroy(parser); |
| return ret; |
| } |
| /** |
| * Load the file as it is a HTML file |
| * |
| * \param file The file path |
| * \param willBeModified Whether this file will be modified, not used |
| */ |
| dom_document *load_html(const char *file, bool willBeModified) |
| { |
| dom_hubbub_parser *parser = NULL; |
| int handle; |
| int readed; |
| dom_hubbub_error error; |
| dom_document *ret; |
| uint8_t buffer[1024]; |
| dom_hubbub_parser_params params; |
| UNUSED(willBeModified); |
| params.enc = NULL; |
| params.fix_enc = true; |
| params.enable_script = false; |
| params.msg = mymsg; |
| params.script = NULL; |
| params.ctx = NULL; |
| params.daf = NULL; |
| error = dom_hubbub_parser_create(¶ms, &parser, &ret); |
| if (error != DOM_HUBBUB_OK) { |
| fprintf(stderr, "Can't create Hubbub Parser\n"); |
| return NULL; |
| } |
| handle = open(file, O_RDONLY); |
| if (handle == -1) { |
| dom_hubbub_parser_destroy(parser); |
| /* fprintf(stderr, "Can't open test input file: %s\n", file); */ |
| return NULL; |
| } |
| readed = read(handle, buffer, 1024); |
| error = dom_hubbub_parser_parse_chunk(parser, buffer, readed); |
| if (error != DOM_HUBBUB_OK) { |
| dom_hubbub_parser_destroy(parser); |
| fprintf(stderr, "Parsing errors occur\n"); |
| return NULL; |
| } |
| while(readed == 1024) { |
| readed = read(handle, buffer, 1024); |
| error = dom_hubbub_parser_parse_chunk(parser, buffer, readed); |
| if (error != DOM_HUBBUB_OK) { |
| dom_hubbub_parser_destroy(parser); |
| fprintf(stderr, "Parsing errors occur\n"); |
| return NULL; |
| } |
| } |
| error = dom_hubbub_parser_completed(parser); |
| if (error != DOM_HUBBUB_OK) { |
| dom_hubbub_parser_destroy(parser); |
| fprintf(stderr, "Parsing error when construct DOM\n"); |
| return NULL; |
| } |
| dom_hubbub_parser_destroy(parser); |
| return ret; |
| } |
| /contrib/network/netsurf/libdom/test/testutils/utils.c |
|---|
| 0,0 → 1,41 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "utils.h" |
| void *myrealloc(void *ptr, size_t len, void *pw) |
| { |
| UNUSED(pw); |
| return realloc(ptr, len); |
| } |
| void mymsg(uint32_t severity, void *ctx, const char *msg, ...) |
| { |
| va_list l; |
| UNUSED(ctx); |
| va_start(l, msg); |
| fprintf(stderr, "%d: ", severity); |
| vfprintf(stderr, msg, l); |
| fprintf(stderr, "\n"); |
| } |
| char *domts_strndup(const char *s, size_t len) |
| { |
| size_t retlen = min(strlen(s), len); |
| char *ret = calloc(retlen + 1, 1); |
| memcpy(ret, s, retlen); |
| return ret; |
| } |
| /contrib/network/netsurf/libdom/test/testutils/utils.h |
|---|
| 0,0 → 1,37 |
| /* |
| * This file is part of libdom test suite. |
| * Licensed under the MIT License, |
| * http://www.opensource.org/licenses/mit-license.php |
| * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org> |
| */ |
| #ifndef utils_h_ |
| #define utils_h_ |
| #include <stddef.h> |
| #include <inttypes.h> |
| #ifndef max |
| #define max(a,b) ((a)>(b)?(a):(b)) |
| #endif |
| #ifndef min |
| #define min(a,b) ((a)<(b)?(a):(b)) |
| #endif |
| #ifndef SLEN |
| /* Calculate length of a string constant */ |
| #define SLEN(s) (sizeof((s)) - 1) /* -1 for '\0' */ |
| #endif |
| #ifndef UNUSED |
| #define UNUSED(x) ((x) = (x)) |
| #endif |
| void *myrealloc(void *ptr, size_t len, void *pw); |
| void mymsg(uint32_t severity, void *ctx, const char *msg, ...); |
| char *domts_strndup(const char *s, size_t len); |
| #endif |
| /contrib/network/netsurf/libdom/test/transform.pl |
|---|
| 0,0 → 1,23 |
| #!/usr/bin/perl |
| # This file is part of libdom. |
| # It is used to generate libdom test files from the W3C DOMTS. |
| # |
| # Licensed under the MIT License, |
| # http://www.opensource.org/licenses/mit-license.php |
| # Author: Bo Yang <struggleyb.nku@gmail.com> |
| use warnings; |
| use strict; |
| use lib qw(test); |
| use XML::Parser::PerlSAX; |
| use DOMTSHandler; |
| if ($#ARGV ne 2) { |
| die "Usage: perl transform.pl dtd-file testcase basedir testcase-file"; |
| } |
| my $handler = DOMTSHandler->new($ARGV[0], $ARGV[1]); |
| my $parser = XML::Parser::PerlSAX->new(Handler => $handler); |
| $parser->parse(Source => {SystemId => "$ARGV[2]"}); |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
