9a97827eada281ff03e044c57fedf7273b7c17f4
[WebKit-https.git] / Tools / TestWebKitAPI / Tests / WebKit2Gtk / DOMNodeFilterTest.cpp
1 /*
2  * Copyright (C) 2013 Igalia S.L.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB.  If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  */
19
20 #include "config.h"
21
22 #include "WebProcessTest.h"
23 #include <gio/gio.h>
24 #include <webkit2/webkit-web-extension.h>
25 #include <wtf/gobject/GUniquePtr.h>
26
27 typedef struct _WebKitNodeFilter {
28     GObject parent;
29 } WebKitNodeFilter;
30
31 typedef struct _WebKitNodeFilterClass {
32     GObjectClass parentClass;
33 } WebKitNodeFilterClass;
34
35 static short webkitNodeFilterAcceptNode(WebKitDOMNodeFilter*, WebKitDOMNode* node)
36 {
37     // Filter out input elements.
38     return WEBKIT_DOM_IS_HTML_INPUT_ELEMENT(node) ? WEBKIT_DOM_NODE_FILTER_REJECT : WEBKIT_DOM_NODE_FILTER_ACCEPT;
39 }
40
41 static void webkitNodeFilterDOMNodeFilterIfaceInit(WebKitDOMNodeFilterIface* iface)
42 {
43     iface->accept_node = webkitNodeFilterAcceptNode;
44 }
45
46 G_DEFINE_TYPE_WITH_CODE(WebKitNodeFilter, webkit_node_filter, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE(WEBKIT_DOM_TYPE_NODE_FILTER, webkitNodeFilterDOMNodeFilterIfaceInit))
47
48 static void webkit_node_filter_init(WebKitNodeFilter*)
49 {
50 }
51
52 static void webkit_node_filter_class_init(WebKitNodeFilterClass*)
53 {
54 }
55
56 static const char* expectedNodesAll[] = { "HTML", "HEAD", "TITLE", "#text", "BODY", "INPUT", "INPUT", "BR" };
57 static const char* expectedNodesNoInput[] = { "HTML", "HEAD", "TITLE", "#text", "BODY", "BR" };
58 static const char* expectedElementsNoInput[] = { "HTML", "HEAD", "TITLE", "BODY", "BR" };
59
60 class WebKitDOMNodeFilterTest : public WebProcessTest {
61 public:
62     static PassOwnPtr<WebProcessTest> create() { return adoptPtr(new WebKitDOMNodeFilterTest()); }
63
64 private:
65     guint64 webPageFromArgs(GVariant* args)
66     {
67         GVariantIter iter;
68         g_variant_iter_init(&iter, args);
69
70         const char* key;
71         GVariant* value;
72         while (g_variant_iter_loop(&iter, "{&sv}", &key, &value)) {
73             if (!strcmp(key, "pageID") && g_variant_classify(value) == G_VARIANT_CLASS_UINT64)
74                 return g_variant_get_uint64(value);
75         }
76
77         g_assert_not_reached();
78         return 0;
79     }
80
81     bool testTreeWalker(WebKitWebExtension* extension, GVariant* args)
82     {
83         WebKitWebPage* page = webkit_web_extension_get_page(extension, webPageFromArgs(args));
84         g_assert(WEBKIT_IS_WEB_PAGE(page));
85         WebKitDOMDocument* document = webkit_web_page_get_dom_document(page);
86         g_assert(WEBKIT_DOM_IS_DOCUMENT(document));
87
88         WebKitDOMElement* root = webkit_dom_document_get_element_by_id(document, "root");
89         g_assert(WEBKIT_DOM_IS_NODE(root));
90
91         // No filter.
92         WebKitDOMTreeWalker* walker = webkit_dom_document_create_tree_walker(document, WEBKIT_DOM_NODE(root), WEBKIT_DOM_NODE_FILTER_SHOW_ALL, nullptr, FALSE, nullptr);
93         g_assert(WEBKIT_DOM_IS_TREE_WALKER(walker));
94         g_assert(!webkit_dom_tree_walker_get_filter(walker));
95
96         unsigned i = 0;
97         for (WebKitDOMNode* node = WEBKIT_DOM_NODE(root); node; node = webkit_dom_tree_walker_next_node(walker), ++i) {
98             g_assert_cmpuint(i, <, G_N_ELEMENTS(expectedNodesAll));
99             GUniquePtr<char> nodeName(webkit_dom_node_get_node_name(node));
100             g_assert_cmpstr(nodeName.get(), ==, expectedNodesAll[i]);
101         }
102         g_assert_cmpuint(i, ==, G_N_ELEMENTS(expectedNodesAll));
103
104         // Input elements filter.
105         GRefPtr<WebKitDOMNodeFilter> filter = adoptGRef(static_cast<WebKitDOMNodeFilter*>(g_object_new(webkit_node_filter_get_type(), nullptr)));
106         walker = webkit_dom_document_create_tree_walker(document, WEBKIT_DOM_NODE(root), WEBKIT_DOM_NODE_FILTER_SHOW_ALL, filter.get(), FALSE, nullptr);
107         g_assert(WEBKIT_DOM_IS_TREE_WALKER(walker));
108         g_assert(webkit_dom_tree_walker_get_filter(walker) == filter.get());
109
110         i = 0;
111         for (WebKitDOMNode* node = WEBKIT_DOM_NODE(root); node; node = webkit_dom_tree_walker_next_node(walker), ++i) {
112             g_assert_cmpuint(i, <, G_N_ELEMENTS(expectedNodesNoInput));
113             GUniquePtr<char> nodeName(webkit_dom_node_get_node_name(node));
114             g_assert_cmpstr(nodeName.get(), ==, expectedNodesNoInput[i]);
115         }
116         g_assert_cmpuint(i, ==, G_N_ELEMENTS(expectedNodesNoInput));
117
118         // Show only elements, reusing the input filter.
119         walker = webkit_dom_document_create_tree_walker(document, WEBKIT_DOM_NODE(root), WEBKIT_DOM_NODE_FILTER_SHOW_ELEMENT, filter.get(), FALSE, nullptr);
120         g_assert(WEBKIT_DOM_IS_TREE_WALKER(walker));
121         g_assert(webkit_dom_tree_walker_get_filter(walker) == filter.get());
122
123         i = 0;
124         for (WebKitDOMNode* node = WEBKIT_DOM_NODE(root); node; node = webkit_dom_tree_walker_next_node(walker), ++i) {
125             g_assert_cmpuint(i, <, G_N_ELEMENTS(expectedElementsNoInput));
126             GUniquePtr<char> nodeName(webkit_dom_node_get_node_name(node));
127             g_assert_cmpstr(nodeName.get(), ==, expectedElementsNoInput[i]);
128         }
129         g_assert_cmpuint(i, ==, G_N_ELEMENTS(expectedElementsNoInput));
130
131         return true;
132     }
133
134     bool testNodeIterator(WebKitWebExtension* extension, GVariant* args)
135     {
136         WebKitWebPage* page = webkit_web_extension_get_page(extension, webPageFromArgs(args));
137         g_assert(WEBKIT_IS_WEB_PAGE(page));
138         WebKitDOMDocument* document = webkit_web_page_get_dom_document(page);
139         g_assert(WEBKIT_DOM_IS_DOCUMENT(document));
140
141         WebKitDOMElement* root = webkit_dom_document_get_element_by_id(document, "root");
142         g_assert(WEBKIT_DOM_IS_NODE(root));
143
144         // No filter.
145         WebKitDOMNodeIterator* iter = webkit_dom_document_create_node_iterator(document, WEBKIT_DOM_NODE(root), WEBKIT_DOM_NODE_FILTER_SHOW_ALL, nullptr, FALSE, nullptr);
146         g_assert(WEBKIT_DOM_IS_NODE_ITERATOR(iter));
147         g_assert(!webkit_dom_node_iterator_get_filter(iter));
148
149         unsigned i = 0;
150         while (WebKitDOMNode* node = webkit_dom_node_iterator_next_node(iter, nullptr)) {
151             g_assert_cmpuint(i, <, G_N_ELEMENTS(expectedNodesAll));
152             GUniquePtr<char> nodeName(webkit_dom_node_get_node_name(node));
153             g_assert_cmpstr(nodeName.get(), ==, expectedNodesAll[i]);
154             i++;
155         }
156         g_assert_cmpuint(i, ==, G_N_ELEMENTS(expectedNodesAll));
157
158         // Input elements filter.
159         GRefPtr<WebKitDOMNodeFilter> filter = adoptGRef(static_cast<WebKitDOMNodeFilter*>(g_object_new(webkit_node_filter_get_type(), nullptr)));
160         iter = webkit_dom_document_create_node_iterator(document, WEBKIT_DOM_NODE(root), WEBKIT_DOM_NODE_FILTER_SHOW_ALL, filter.get(), FALSE, nullptr);
161         g_assert(WEBKIT_DOM_IS_NODE_ITERATOR(iter));
162         g_assert(webkit_dom_node_iterator_get_filter(iter) == filter.get());
163
164         i = 0;
165         while (WebKitDOMNode* node = webkit_dom_node_iterator_next_node(iter, nullptr)) {
166             g_assert_cmpuint(i, <, G_N_ELEMENTS(expectedNodesNoInput));
167             GUniquePtr<char> nodeName(webkit_dom_node_get_node_name(node));
168             g_assert_cmpstr(nodeName.get(), ==, expectedNodesNoInput[i]);
169             i++;
170         }
171         g_assert_cmpuint(i, ==, G_N_ELEMENTS(expectedNodesNoInput));
172
173         // Show only elements, reusing the input filter.
174         iter = webkit_dom_document_create_node_iterator(document, WEBKIT_DOM_NODE(root), WEBKIT_DOM_NODE_FILTER_SHOW_ELEMENT, filter.get(), FALSE, nullptr);
175         g_assert(WEBKIT_DOM_IS_NODE_ITERATOR(iter));
176         g_assert(webkit_dom_node_iterator_get_filter(iter) == filter.get());
177
178         i = 0;
179         while (WebKitDOMNode* node = webkit_dom_node_iterator_next_node(iter, nullptr)) {
180             g_assert_cmpuint(i, <, G_N_ELEMENTS(expectedElementsNoInput));
181             GUniquePtr<char> nodeName(webkit_dom_node_get_node_name(node));
182             g_assert_cmpstr(nodeName.get(), ==, expectedElementsNoInput[i]);
183             i++;
184         }
185         g_assert_cmpuint(i, ==, G_N_ELEMENTS(expectedElementsNoInput));
186
187         return true;
188     }
189
190     virtual bool runTest(const char* testName, WebKitWebExtension* extension, GVariant* args)
191     {
192         if (!strcmp(testName, "tree-walker"))
193             return testTreeWalker(extension, args);
194         if (!strcmp(testName, "node-iterator"))
195             return testNodeIterator(extension, args);
196
197         g_assert_not_reached();
198         return false;
199     }
200 };
201
202 static void __attribute__((constructor)) registerTests()
203 {
204     REGISTER_TEST(WebKitDOMNodeFilterTest, "WebKitDOMNodeFilter/tree-walker");
205     REGISTER_TEST(WebKitDOMNodeFilterTest, "WebKitDOMNodeFilter/node-iterator");
206 }
207
208